Create Curve from Path of an Object Using Geometry Nodes

Question

I am wondering if there is a way, using geometry nodes, to "draw" a curve from a moving object.

Here I've created a short animation of a line segment using geometry nodes. I would like the endpoint of this segment to draw out a curve as it rotates. This would create a helix around the x-axis as the animation plays.

My Thoughts:

I am aware that one way to draw a curve would be to just parameterize said curve and draw it using math, like explained in this answer. This is fine when the curves are simple. In my example, the line segment is just tracing a helix and this is easy to parameterize mathematically. However, I would like to be able to animate my line segment in much more complicated ways and see the resulting curve it traces out without having to stop and parameterize the curve every time.

I'm thinking that if I can access the position of my line segment's endpoint, then I can plug this in to a Set Position node that controls a Mesh Line whose count grows with the Scene Time. So far, however, I've been unable to figure out how to access the position of the endpoint of my line segment, and I'm not even sure if I'm going in the right direction with that thought process. Help is appreciated!

In case it is important, here is my node setup for the animated line segment.

Answer 1

A possible solution could look like this:

The trick here is that I pre-calculate the result at the beginning, and then simply remove the points that are above the current frame.

The positions of the Mesh Line are calculated in the same way as the transformation of the rotating line.

And here is another variation of the solution shown here, which is based on curves and reduces the duplicate nodes:

_{(Blender 3.2+)}

Answer 2

Currently Geometry Nodes, like almost everything else in Blender, are evaluated separately for each frame, there's no temporal continuity in a logical sense. You can't easily access a previous position of something, similarly how in a shader you can't easily access a neighboring sample/pixel. You can figure out what's supposed to be there, if you have an access to the logic that draws it. This means for more complex problems you could calculate the object position for each previous frame, with a triangular growth of performance cost, as a 1000 frame long animation would require all 1000 frames to be calculated just on the last frame; average 500 frames calculated per frame. A 2 hours long animation at 60 FPS would increase the average performance cost of the node tree $2 × 3600 ÷ 2 × 60 = 216,000$ times!

Also, quellenform's or my proposed solution above wouldn't be able to calculate positions in cases when they are based on external data like object position.

So what are the alternatives? First is using a driver. However a simple driver won't allow you to read a previous state. What you need is to use Python, and access functionality outside of the whitelisted sandbox set, in order to either:

• at the beginning of evaluation read a state saved earlier, and at the end of evaluation save the final state for the frame;
• at the beginning of evaluation evaluate previous frame and read data from it.

The first of the approaches requires somehow using a driver to store data, which would be unreadable even for driver hacking standards. The alternative still suffers from the triangular growth problem, because it's recursive (not to mention you may run out of memory through a very long recursion).

So rather than using a driver with just a little out-of-sandbox hack to access a previous frame, this ends up to be a complex solution, where you duplicate an attribute array for each frame, deal with a problem that it may have a different length before/after evaluation, deal with the fact your geonodes modifier might be just one of many, deal with caching, but also with a way to allow to refresh the cache... This problem is too complex for drivers, and if you just want to use Python for an iterative animation, here are good starting points:

How to add driver expression result from previous frame to current frames expression (way to compound expression output?)

Distributed interaction visualization

Pin cloth solution

An exception from the stateless nature of Blender, where each but the first frame depends on a previous one, is physics. This solution uses my previous answer where I figured how to dynamically change the PIN group by using geonodes:

Assign vertex group in Geometry Nodes (v3.3)

The idea is simple: based on frame number apply a PIN mask to your vertices - only those vertices will be moved by the cloth modifier, and the rest will stay in place.

Modifier stack: (refer to the linked answer for their settings)

Geonodes Main:

(faces are needed for boolean, but then excess vertices are removed just to end up with a mesh line)

Cloth settings:

Possibly not all of these settings are needed, the idea is that the cloth modifier is not actually supposed to simulate anything - it only keeps the previous positions and updates the positions of the PIN group:

I start the animation and simulation at frame #0, because the vertices start at index 0 and I wanted to keep the node trees simple:

Geonodes Postprocess:

Result