Particle orientation along a path

Hi Folks,

is there a way to "auto-orient" emitted particles to the path of a moving emitter region? I searched this board, google, tutorials and stuff and didn't find a useable solution. I also watched this classic YT:

from eyeon, but to emit particles along a path is not the problem here.

From everything I've read so far, it could well be that the particle system in Fusion does not allow this modification, or has not built it in.
So I hope that maybe someone knows a trick to customize the emitted particles as desired

For demonstration purposes this simple comp:

I have a rotating 3D object, in this case the animation describe a simple circle. I have mapped my particle emitting region (a rectangle) to the movement and rotation of the 3D object. (I know, I could also emit from the 3D object itself). The emitter follows perfect in position and rotation, well.

As particle I use a custom bitmap (tiny arrows for this demonstration). The result looks something like this (picture 01):

Particle01.png (101.5 KiB) Viewed 2232 times

The animation starts at the bottom left and goes up to the top center. As you can see, the arrows point upwards, which would be correct at the beginning of the animation. However, they retain this orientation if the emitter changes its orientation during the animation.

When the emitter has reached the top, the arrows should actually have this orientation - picture 2. Actually always an angle of 90° to the orientation of the emitter at the time when the particle is emitted.

Particle02.png (106 KiB) Viewed 2232 times

How can I achive something like that - picture 03:

Particle03.png (94.99 KiB) Viewed 2232 times

I hope someone can help me here, otherwise I'll have to animate my desired particle sprites with a 7 year old generator in After Effects and bring them back together in Fusion at the end.

Thank you

I am not 100% sure I understand you correctly. Do the arrows need to move along the path? Or does the orientation of the arrows need to align to the direction of the path at the moment of creation?
i.e. do the arrows move or are they created along a path?

This is probably 90% of the way there.

Code: Select all

{
   Tools = ordered() {
      sRectangle1 = sRectangle {
         Inputs = {
            ["Translate.Y"] = Input { Value = -0.130677290836653, },
            Width = Input { Value = 0.125, },
            Height = Input { Value = 0.25, }
         },
         ViewInfo = OperatorInfo { Pos = { 165, 49.5 } },
      },
      pEmitter1 = pEmitter {
         ID = 7,
         CtrlWZoom = false,
         Inputs = {
            Number = Input { Value = 0.2, },
            TemporalDistribution = Input { Value = 2, },
            VelocityControls = Input { Value = 1, },
            RotationControls = Input { Value = 1, },
            AlwaysFaceCamera = Input { Value = 0, },
            RotationZ = Input {
               SourceOp = "pEmitter1Z",
               Source = "Value",
            },
            Style = Input { Value = FuID { "ParticleStyleBitmap" }, },
            ["ParticleStyleBitmap.DropToolsHere"] = Input {
               SourceOp = "sRender1",
               Source = "Output",
            },
            Region = Input { Value = FuID { "RectRgn" }, },
            ["ParticleStyle.SizeOverLife"] = Input {
               SourceOp = "pEmitter1SizeOverLife",
               Source = "Value",
            },
            ["ParticleStyle.BlurOverLife"] = Input {
               SourceOp = "pEmitter1BlurOverLife2D",
               Source = "Value",
            },
            ["RectRgn.Width"] = Input { Value = 0.0001, },
            ["RectRgn.Height"] = Input { Value = 0.001, },
            ["RectRgn.Translate.X"] = Input { Value = -0.5, },
            ["RectRgn.Rotate.Z"] = Input {
               SourceOp = "pEmitter1ZRotation",
               Source = "Value",
            },
            ["RectRgn.Pivot.X"] = Input {
               Value = 0.25,
               Expression = "-RectRgn.Translate.X",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 660, 16.5 } },
      },
      pEmitter1Z = BezierSpline {
         SplineColor = { Red = 0, Green = 0, Blue = 255 },
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 33.6666666666667, -120 }, Flags = { Linear = true } },
            [101] = { -360, LH = { 67.3333333333333, -240 }, Flags = { Linear = true } }
         }
      },
      pEmitter1SizeOverLife = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 0.5, RH = { 0.3, 0.5 }, Flags = { Linear = true } },
               [1] = { 0.5, LH = { 0.7, 0.5 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
         NameSet = true,
      },
      pEmitter1BlurOverLife2D = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 0.5, RH = { 0.3, 0.5 }, Flags = { Linear = true } },
               [1] = { 0.5, LH = { 0.7, 0.5 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
         NameSet = true,
      },
      pEmitter1ZRotation = BezierSpline {
         SplineColor = { Red = 128, Green = 128, Blue = 255 },
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 33.6666666666667, -120 }, Flags = { Linear = true } },
            [101] = { -360, LH = { 67.3333333333333, -240 }, Flags = { Linear = true } }
         }
      },
      sRender1 = sRender {
         Inputs = {
            GlobalOut = Input { Value = 100, },
            Width = Input { Value = 512, },
            Height = Input { Value = 512, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Input = Input {
               SourceOp = "sTransform1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 550, 82.5 } },
      },
      sTransform1 = sTransform {
         Inputs = {
            YOffset = Input { Value = 0.12890625, },
            XSize = Input { Value = 2.14, },
            YSize = Input {
               Value = 1.57,
               Expression = "XSize",
            },
            Input = Input {
               SourceOp = "sMerge1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 440, 82.5 } },
      },
      sMerge1 = sMerge {
         Inputs = {
            Input1 = Input {
               SourceOp = "sRectangle1",
               Source = "Output",
            },
            Input2 = Input {
               SourceOp = "sNGon1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 330, 82.5 } },
      },
      sNGon1 = sNGon {
         Inputs = {
            Sides = Input { Value = 3, },
            Width = Input { Value = 0.25, },
            Height = Input { Value = 0.25, },
            Angle = Input { Value = 90, }
         },
         ViewInfo = OperatorInfo { Pos = { 165, 82.5 } },
      },
      pRender1 = pRender {
         Inputs = {
            _MotionBlurWarning = Input { Disabled = true, },
            GlobalOut = Input { Value = 100, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            ["MaterialID.MaterialID"] = Input { Value = 1, },
            ["ObjectID.ObjectID"] = Input { Value = 1, },
            Input = Input {
               SourceOp = "pEmitter1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 935, 16.5 } },
      }
   }
}

Pretty much what Sander did. It should get you mostly there. Depending on what you wan to do.

To borrow Sander example, if you use replicate 3D you can drive 3D objects based on particle movement. So you can expand on this if you need 3D objects. Otherwise its even simple with 2D.

sshot-1193.jpg (213.08 KiB) Viewed 2117 times

replicate3D with particles.zip

(6.85 KiB) Downloaded 36 times

P.S.

There was that other tutorial, from DarkWhite Productions. Not sure if you watched that one.

QuickTip - 3D Particles Along a Path in Fusion ¦ DaVinci Resolve

Thanks Sander, Kruno.

To clearify my needs. The orientation of the arrows have to align to the orientation to the direction of the path at the moment of their creation.

In my actual composition I don't use arrows but a set of sprite shapes. I try to visualize the trajectory of electrons around an atomic nucleus. Not as a real physical visualization but in a stylish variation. The trajectory, which is aligned in front of the camera, is the least problematic because the dimension and orientation of the particle sprites is not really recognizable. If I then duplicate this one trajectory and rotate it around the atomic nucleus, you can see the sprites and their alignment to the nucleus/trajectory.

As an example, here is a screenshot of my project. The look of the particle is not final, I wanted to get the physics right first.

Picture 01 - single:

Nucleus01.png (229.91 KiB) Viewed 2085 times

Picture 02 - duplicated:

Nucleus02.png (327.4 KiB) Viewed 2085 times

As you can see in picture 02, the bitmap sprites are not aligned to their movement around the nucleus and that looks a little bit akward.

I will definitly try the mentioned method with the repilcate3D node. But I am not sure if I can also replicate the behavior of the particles.

Then it occurred to me to link a camera to the movement and rotation of the emitter region and to always align the particle to the camera (“face always to camera”). In other words, to have a camera that is permanently pointed at the emitter surface and to adapt the alignment of the particle to it.

And then ultimately “film” this particle stream with a second camera. I have no idea whether this works in fusion.

I will do some checks and report back again.


Thank you very much.

Have you tried what I posted? Because I think it does 90% of what you're asking, depending on how you want to set it up. I imagine that the trajectory is quite mathematical in its approach. That's why I used an offset pivot to create the path of my emitter with the added bonus that the rotation of the emitter can drive the rotation of the sprites.

Got it! Thank you very much Sander and Kruno.

Tried both of your comps and in the first moment I was very baffled, because I tried a fresh particle comp only with a moving and rotating emitter region (as mentioned) and got the same messy result. Also the repilcator didn't worked for me. I could exchange the particles to 3D objects, but they disappeared as I swichted to "align" or "TBN align" in the replicator.

Then I found my mistake. I have to animate the particle rotation over time. In my case it's the Z-rotation, so I connected it to the rotation of my emitter-region with an offset, and boom - problem solved.


Solution:

Rotation.png (92.88 KiB) Viewed 2022 times

Result:

RotationResult.png (63.56 KiB) Viewed 2022 times

Sorry guys, apparently my head has been in other software for too many years. So thanks again, now I can finally get back to the creative stuff.

Robert.

Apparently I need to work on my SEO

https://bryanray.name/2016/04/23/linkin ... ic-fusion/