Saving/Reusing Fusion Background Animation

I'm fairly new to Resolve and could use some help for what are best practices in saving a background animation for reuse. I've built a background animation in Fusion of scolling text based on this tutorial

(the effect is shown at 4:10).
Mine is a bit more complex with different text lines scrolling at different speeds.

I will be using this quite a lot in videos, both as a background for the entire video, as well as a sidebar for the left 15% area of the video. The videos that I plan to use it for will be quite long, up to an hour.

I tried it out with a first video and it took about 7 hours to render for 45 minutes of video. Of course, I don't want to go through that every time. Hence I need to save the background and here is where I could use some input what the best approach would be.

I know I could use a "saver node" in Fusion and render that.
I also could just render it as a standalone video.
What are the benefits for one or the other?

The other question is, will I need to save/render the maximum length that I'd need that background (i.e., an hour), or is there a smarter way of doing it. I'm sure there's a way to loop the video but in order to not have the text jump at every loop I'd need to ensure somehow that I render exactly the amount of frames needed for each line of text to be back at its original position. And here, other than trial and error, how can I find that out ... or is there a better approach?

Your input is much appreciated.

For what you are describing you should probably try to design your background as a loopable element.

Depending on what you have done, will dictate how it can be made loopable. Once it is loopable, you do a saver node, ouput the thing as a movie, or still sequence, and then just use that as a source any other time you need it.

Within fusion, you can import your rendered item, and tell fusion to loop it, so the loopable item you built, can now loop without a jump cut, and Fusion will then loop it automatically, for how ever long your current project needs.

Thank you, Glenn, for your suggestions.
Yes, looping a shorter clip is the goal.

So, I've done the math, the different animations repeat exactly after 5000 frames, which is, if I'm not mistaken, 2:46:20 at 30fps.

Now I've tested the following options:

Creating a saver node and putting out image sequences (of 5000 files),
first in exr format, then in png.
I've also rendered out a video file through the deliver page.

To generate the image sequence takes 40 minutes for exr files, but eating up a total of 87 GB. It takes 2:30 hours for png files, which still take up 21 GB.

Rendering the video file (an H.264 QuickTime mov file, as it's a background I don't need an alpha channel) takes about 5 minutes and the resulting file is just over 200 MB.
So in that regard, the last option seems clearly the way to go, or am I doing something wrong with the saver node? (like, is there a way to save to a video file through a saver node?)

Now the question remains how to get it to loop.

I've followed the suggestions from this thread
viewtopic.php?f=21&t=70847
generating a fusion composition, adding the video file/image sequence, and checking the Loop box in MediaIn.
I've then extended it to 10 minutes and rendered through the deliver page.

Using the mov file took 2:20 minutes to render.
Using either of the image sequence took between 15 and 20 minutes.

So, long story short, it does seem that the way to go is definitely to create a loopable video file and not using saver nodes for this.

Lastly, I have tried one more option, simply pasting my 2:46 movie file four times into the timeline and rendered. Rendering this out took only a minute and a half.

So my final question: Is there a better way to loop a video file other than going through fusion?
It seems that simply concatenating the videos is still faster than looping in fusion. It also requires it to render first in the edit page which slows down the workflow.

If you are trying to do everything in fusion, then you can use the loop function inside fusion.

If your intention is to use resolve, then just duplicate the clip a few times on the timeline.

I was originally assuming you wanted a loopable element to be able to continue building items in fusion.

Here's a few points that I think covers everything you said:

1. I wouldn't recommend ever saving PNGs from Fusion. As you found, it's exceedingly, and surprisingly slow.

2. When you saved the EXRs I imagine you left the Saver at default, which will save in float32 format. This will use a lot more disk space, and likely be slower, than choosing float16.

You can further reduce disk space by choosing DWA compression, which is a lossy compression similar to JPG. Should still be fine quality for this purpose - especially as you were considering using H264 which will be a lot more compressed than JPG/DWA.

Also, in the Saver node's Channel settings you can also untick the Alpha channel, if you don't need it; that'll save another 25%. Don't worry about unticking all the other channels listed in there that you're not using, they won't be saved if they don't exist.

In other words, set it up like this:


3. In Resolve, always load still images using Loader nodes, not MediaIn. This includes image sequences. See this thread for more information: Fusion page: Major performance issue with MediaIn v Loader.

This does not apply to videos, which have to be loaded via MediaIn nodes.

This may well explain why it took 15-20 minutes to render in Fusion using that EXR image sequence.

4. Resolve's Saver node can't save video footage, only still images and image sequences. To save to a video requires using the Deliver page.

5. 7 hours to render 45 minutes of that effect? That's incredibly slow. Or was that 7 hours of a full video, which included that effect in places?

If it was 7 hours for just the effect, then did you have any still images in the composition? I watched the tutorial and he only used Text and Transform nodes, but maybe you customised it a bit with a still image or two? If so, see point 3.

What are your system specs?

6. If you're going to save the effect to video footage, I'd choose something other than H264. On macOS I'd use ProRes 422. On Windows, I guess DNxHD or CineForm. It'll make the file larger (10x probably) but it'll guarantee perfect quality, and it'll read/write a little faster. Probably doesn't matter in this case, but it's a good general practice.

H264 is great for final delivery, but not recommended as an intermediate format, due both to its extra computational requirements, and some loss in quality.

7. I remain amazed that you can't just keep this as a Fusion composition that you deploy as needed and have render live. Can you post the nodes you ended up using to create the scrolling text effect? To do this, select all the nodes, copy them, then paste them into the forum, surrounded by Code tags. You can place the Code tags by clicking the Code button at the top of the editor. Then we can see exactly how you've set up your composition.

But if this does remain a problem, then personally I think I would start with saving the footage in such a way that it loops correctly, then include it in the Fusion composition via a looping Loader (using an EXR image sequence) or MediaIn (using video footage)

If you use Loader + EXR, you will be able to store your Fusion Composition in a Power Bin for easy deployment in any future composition in any project: in the future you can simply drag it in from the Power Bind and drop it on any timeline, set it to length, and done.

I say to use Loader + EXR because I think use of Power Bins will require that you use a Loader node, because MediaIn nodes are specific to the project - if you used a MediaIn node, you'd a) need to make sure each new project had the video footage imported into its Media Pool, and b) go into the Fusion Composition after dragging it from the Power Bin, and update the MediaIn to point to the current version in this project's Media Pool.

Using a Loader instead is generic, because the footage gets pulled from a specific place on disk. But as mentioned this does require saving the footage as an image sequence, because Resolve's Loader nodes have been blocked from loading video footage.

I don't see using Loader + EXR as being a problem. You mentioned 87GB of EXRs, but a) as discussed above it can be much smaller than this per-file, if you save to float16, DWA, and without Alpha, and b) you shouldn't need anywhere near as many frames as you saved in your tests. Just as many as necessary to do one cycle of the loop. A few hundred maybe?

Or yes you could just repeat the footage X times on your timeline. That feels a little messy and inelegant to me, but it'll certainly work and is easy. Just you'll have to do it each time you use the footage; it's not possible to save a Compound Clip or Timeline to a Power Bin, so you can't save a timeline that already has the footage arranged to loop.

So, TLDR: Share your nodes you created from the tutorial, the ones that are taking 7 hours to render for 45 mins, and we'll take a look to see if there's any obvious explanation as to why it's so slow. Also share your system specs.

Then try making a rendered, loopable version of your effect, saved to EXR in float16 / DWA / no alpha, and only saving as many frames as are needed for one loop. Bring this into a Fusion Composition via Loader node set to Loop, and see how you get on with using that. If it works well, drag that composition to a Power Bin and now you can deploy it to any and all future projects.

Thank you all for your feedback and suggestions!

@Glenn: Yes, I'll be using the composition as is, simply as a background, so it won't be needed in fusion anymore. Hence, it may be that rendering one loop as movie file and then duplicating the clip on the timeline would be the best option in this case (It's the fastest option so far at least, without involving Fusion at all).

@Tom:
My system specs: 2017 MacBook Pro with 2.9 GHz Intel Core i7, 16 GB RAM, GPU Radeon Pro 560 4 GB.
The one that took 7 hours was not only the fusion effect, but the effect as part of an entire movie. So there were other things going on. I just tried to output an hour of only the effect and it took 2 hours to render. Gave me a file of just under 3GB (I had already put it to render when I saw your post so that again was in H.264).

Here's my setup of the Fusion composition:

Code: Select all

{
   Tools = ordered() {
      Primary_Text = TextPlus {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 134999, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 600, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Center = Input { Value = { 0.5, 0.9 }, },
            Red1 = Input { Value = 0.984313725490196, },
            Green1 = Input { Value = 0.976470588235294, },
            Blue1 = Input { Value = 0.933333333333333, },
            StyledText = Input { Value = "language, culture, and communication", },
            Font = Input { Value = "Ysabeau SC", },
            Style = Input { Value = "Light", },
            Size = Input { Value = 0.085, },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
            ManualFontKerningPlacement = Input {
               Value = StyledText {
                  Array = {
                  },
                  Value = ""
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { 55, 148.5 } },
      },
      Instance_B = TextPlus {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 134999, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 600, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Center = Input { Value = { 0.5, 0.65 }, },
            Red1 = Input { Value = 0.529411764705882, },
            Green1 = Input { Value = 0.52156862745098, },
            Blue1 = Input { Value = 0.498039215686275, },
            StyledText = Input { Value = "language, culture, and communication", },
            Font = Input { Value = "Ysabeau SC", },
            Style = Input { Value = "Light", },
            Size = Input { Value = 0.085, },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
            ManualFontKerningPlacement = Input {
               Value = StyledText {
                  Array = {
                  },
                  Value = ""
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { 55, 181.5 } },
      },
      Instance_C = TextPlus {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 134999, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 600, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Center = Input { Value = { 0.5, 0.4 }, },
            Red1 = Input { Value = 0.317647058823529, },
            Green1 = Input { Value = 0.313725490196078, },
            Blue1 = Input { Value = 0.298039215686275, },
            StyledText = Input { Value = "language, culture, and communication", },
            Font = Input { Value = "Ysabeau SC", },
            Style = Input { Value = "Light", },
            Size = Input { Value = 0.085, },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
            ManualFontKerningPlacement = Input {
               Value = StyledText {
                  Array = {
                  },
                  Value = ""
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { 55, 214.5 } },
      },
      Instance_D = TextPlus {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 134999, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 600, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Center = Input { Value = { 0.5, 0.15 }, },
            Red1 = Input { Value = 0.886274509803922, },
            Green1 = Input { Value = 0.874509803921569, },
            Blue1 = Input { Value = 0.83921568627451, },
            StyledText = Input { Value = "language, culture, and communication", },
            Font = Input { Value = "Ysabeau SC", },
            Style = Input { Value = "Light", },
            Size = Input { Value = 0.085, },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
            ManualFontKerningPlacement = Input {
               Value = StyledText {
                  Array = {
                  },
                  Value = ""
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { 55, 247.5 } },
      },
      Transform_C = Transform {
         NameSet = true,
         SourceOp = "Transform_A",
         Inputs = {
            EffectMask = Input { },
            SettingsNest = Input { },
            TransformNest = Input { },
            Center = Input {
               SourceOp = "Path3",
               Source = "Position",
            },
            ReferenceSize = Input { },
            Input = Input {
               SourceOp = "Instance_C",
               Source = "Output",
            },
            CommentsNest = Input { },
            FrameRenderScriptNest = Input { },
            StartRenderScripts = Input { },
            EndRenderScripts = Input { },
         },
         ViewInfo = OperatorInfo { Pos = { 165, 214.5 } },
      },
      Path3 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path3Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, LockY = true, X = 0.1, Y = 0, RX = -0.00666666666666667, RY = 0 },
                     { Linear = true, LockY = true, X = 0.08, Y = 0, LX = 0.00666666666666667, LY = 0 }
                  }
               },
            },
         },
      },
      Path3Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 16.6666666666667, 0.333333333333333 }, Flags = { Linear = true, LockedY = true, Loop = true, LoopRel = true } },
            [50] = { 1, LH = { 33.3333333333333, 0.666666666666667 }, Flags = { Linear = true, LockedY = true, Loop = true, LoopRel = true } }
         }
      },
      Transform_D = Transform {
         NameSet = true,
         SourceOp = "Transform_C",
         Inputs = {
            EffectMask = Input { },
            SettingsNest = Input { },
            TransformNest = Input { },
            Center = Input {
               SourceOp = "Path4",
               Source = "Position",
            },
            ReferenceSize = Input { },
            Input = Input {
               SourceOp = "Instance_D",
               Source = "Output",
            },
            CommentsNest = Input { },
            FrameRenderScriptNest = Input { },
            StartRenderScripts = Input { },
            EndRenderScripts = Input { },
         },
         ViewInfo = OperatorInfo { Pos = { 220, 247.5 } },
      },
      Path4 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path4Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, LockY = true, X = 0.05, Y = 0, RX = 0.0166666666666666, RY = 0 },
                     { Linear = true, LockY = true, X = 0.1, Y = 0, LX = -0.0166666666666666, LY = 0 }
                  }
               },
            },
         },
      },
      Path4Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 16.6666666666667, 0.333333333333333 }, Flags = { Linear = true, LockedY = true, Loop = true, LoopRel = true } },
            [50] = { 1, LH = { 33.3333333333333, 0.666666666666667 }, Flags = { Linear = true, LockedY = true, Loop = true, LoopRel = true } }
         }
      },
      Transform_A = Transform {
         NameSet = true,
         Inputs = {
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Edges = Input { Value = 1, },
            Input = Input {
               SourceOp = "Primary_Text",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 220, 148.5 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, LockY = true, X = -0.05, Y = 0, RX = -0.0133333333333333, RY = 0 },
                     { Linear = true, LockY = true, X = -0.09, Y = 0, LX = 0.0133333333333333, LY = 0 }
                  }
               },
            },
         },
      },
      Path1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 16.6666666666667, 0.333333333333333 }, Flags = { Linear = true, LockedY = true, Loop = true, LoopRel = true } },
            [50] = { 1, LH = { 33.3333333333333, 0.666666666666667 }, Flags = { Linear = true, LockedY = true, Loop = true, LoopRel = true } }
         }
      },
      Transform_B = Transform {
         NameSet = true,
         SourceOp = "Transform_A",
         Inputs = {
            EffectMask = Input { },
            SettingsNest = Input { },
            TransformNest = Input { },
            Center = Input {
               SourceOp = "Path2",
               Source = "Position",
            },
            ReferenceSize = Input { },
            Input = Input {
               SourceOp = "Instance_B",
               Source = "Output",
            },
            CommentsNest = Input { },
            FrameRenderScriptNest = Input { },
            StartRenderScripts = Input { },
            EndRenderScripts = Input { },
         },
         ViewInfo = OperatorInfo { Pos = { 275, 181.5 } },
      },
      Path2 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path2Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, LockY = true, X = 0, Y = 0, RX = 0.01, RY = 0 },
                     { Linear = true, LockY = true, X = 0.03, Y = 0, LX = -0.01, LY = 0 }
                  }
               },
            },
         },
      },
      Path2Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 16.6666666666667, 0.333333333333333 }, Flags = { Linear = true, LockedY = true, Loop = true, LoopRel = true } },
            [50] = { 1, LH = { 33.3333333333333, 0.666666666666667 }, Flags = { Linear = true, LockedY = true, Loop = true, LoopRel = true } }
         }
      },
      Merge_AB = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "Transform_A",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Transform_B",
               Source = "Output",
            },
            Edges = Input { Value = 1, },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 330, 148.5 } },
      },
      Merge_CD = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "Transform_C",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Transform_D",
               Source = "Output",
            },
            Edges = Input { Value = 1, },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 330, 247.5 } },
      },
      Merge_All = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "Merge_AB",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Merge_CD",
               Source = "Output",
            },
            Edges = Input { Value = 1, },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 385, 181.5 } },
      },
      MediaOut1 = MediaOut {
         CtrlWZoom = false,
         Inputs = {
            Index = Input { Value = "0", },
            Input = Input {
               SourceOp = "Merge_Background",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 495, 247.5 } },
      },
      Merge_Background = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Merge_All",
               Source = "Output",
            },
            Size = Input { Value = 0.56, },
            Angle = Input { Value = 20, },
            Edges = Input { Value = 1, },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 495, 181.5 } },
      },
      Background1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 134999, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Type = Input { Value = FuID { "Gradient" }, },
            GradientType = Input { Value = FuID { "Radial" }, },
            Start = Input { Value = { 0.2425, 1.25111111111111 }, },
            End = Input { Value = { 1.09291666666667, -0.22 }, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 1, 0.972549019607843, 0.913725490196078, 1 },
                     [1] = { 0.282352941176471, 0.270588235294118, 0.235294117647059, 1 }
                  }
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { 495, 148.5 } },
      }
   }
}

That composition was sitting on the V1 track extended the entire 1 hour of the movie and then the actual footage on V2 (cropped to different sizes, depending on content, some parts leaving only a left margin of 15% of the width with the effect others with the footage centered and have the effect surround it). I also added other footage, to which I added transparency in Fusion, so that all taken together might be the reason why it took so long to render.

I will try out your suggestion to do a rendered loopable EXR version per your settings and load it through a loader node later today. However, since 5000 frames is the minimum I need for a full loop, I imagine it'll still be quite large. Maybe I can play around with the speed of the transform nodes a bit so that I can get it to repeat already sooner.
I'll also do a ProRes version of one loop and input it through a Fusion loop and also by just copying it and duplicating it on the timeline, to see how that compares.
I'll post back.
Just one more question before, so there is no way to make a clip loopable directly from the timeline (i.e., without involving Fusion)?

Thanks so much for your help and the thorough explanation of everything!

I copied your nodes into Resolve Studio on a 1080p 30 fps timeline, and tried saving to EXR with the settings I showed yesterday, for 5000 frames. This was the result:



It produced 2.2 GB of float16 EXR files.

I tried a Resolve Deliver as well, to ProRes 422, and that took 2 minutes 30 seconds, producing a 1.1GB mov file.

Then it occurred to me we haven't discussed resolution and your file sizes are so large that perhaps you're doing all this in UHD / 4K? So I Delivered at UHD and that took 3 minutes 14 seconds, and produced a 4.3GB file.

Extrapolating that up to 1 hour of the effect would give 70 minutes. So I suppose your 2 hours could be explained by the 4GB GPU and 16GB RAM - I have 48GB RAM, 8GB AMD Vega 64. Though your CPU is much newer than mine. Also if you don't have Studio, you'll have less or no GPU acceleration which could also explain it.

Going back to the EXR Saver, producing 5000 frames at UHD took 26 minutes and produced 9.8GB of float16 EXRs:


So if you are in UHD perhaps your render times are to be expected. Though as discussed there's no need to render 1 hour of the effect, just render the minimum loopable amount, 5000 frames if that is what's required.

Just one more question before, so there is no way to make a clip loopable directly from the timeline (i.e., without involving Fusion)?

No I don't believe there is any way to loop a clip in Resolve besides taking it into Fusion as discussed. The speed adjustment facilities are quite sophisticated, but they don't include a loop option. On Edit you'd have to manually duplicate the clip.

Putting this all together, I think the best method is probably:

1. Deliver a ProRes 422 MOV file of 5000 frames of the effect
2. Import it into the Media Pool of each project that needs it
3. Wherever it's needed, create a Fusion Composition of the desired length, drag the ProRes Mov into the Composition from the Media Pool, creating MediaIn1. Set MediaIn1 to loop.
4. Now use this Fusion Composition on any timeline that needs it in that project.

I just tested that. I had earlier rendered a UHD 5000 frame ProRes 422 Mov, so I made a Fusion Composition that looped that, then set its length to 10,000 frames on a timeline and delivered that to ProRes 422. It took 1 minute 39 seconds to render 10k frames (05:33:12) at UHD. No time at all really.

@Tom: Thanks so much for taking the time to test it all out!
Your explanations and suggestions have been super helpful.

Here's my results when following them:
Saving 5000 frames to float16 EXR files without alpha and with DWA (32 line) compression
did produce 3.35 GB of files (each file 662 or 663 KB). So that's somewhat larger than your 2.2 GB.
And it also took longer than your 8:40 min, in total 22:07 min. That might be explained by the different hardware.

BTW, yes, I also have a 1080p 30 fps timeline in Resolve. So it's not the resolution that's the issue.

Then, I rendered a ProRes 422 mov file. That took only 5 seconds longer than yours, 2:35 to be precise. But the file size is 3.07 GB (for the 5000 frames) so that is quite a bit larger than your 1.1 GB. Are there maybe some other settings that I'm unaware of that would explain why you are getting smaller file sizes with the same settings?

Or maybe it's because I don't have Studio?
Is there something else in the Studio version (other than GPU acceleration, which you mentioned) that might make things more efficient? (I'm going to invest in Studio next month, BTW, it definitely seems worth it. I was first thinking I wait for version 17 to come out, but that might still be a while and I'll be using it quite a bit the next months.)

In any case, your suggested workflow is what I'm going to be using now, first render a mov file and then looping it through fusion.
I did that and tested it and also put some other footage over it to resemble my actual scenario. 2 minutes of footage rendered in 1:15 min. So that does doesn't seem that long to me, given my hardware/software specs.

Thanks so much for your help!

Really interesting thread, thanks for your contributions @TheBloke!