On 7/6/2025 2:45 PM, Caddiy via Discuss wrote:

No, because you need that one circle to go all the way around.  If, say,
you want to avoid jumps larger than one degree, you must have at least
360 frames, because there are 360 different places that the circle can be.

You can't make one iteration of the animation be different from the next
iteration... because then they would be two different animations.

Jordan Brown wrote:

180 + 180 = 360.

With the code I posted earlier on, the two circles don’t jump. But I want one circle. Surely it’s just a matter of hiding them alternately, so it looks like one circle?

Nophead came up with if($t < 0.5) but how could it be timed +$t*90 and -$t*90 respectively for each circle, to hide the circles alternately?

Jordan Brown wrote:

Yes, that is exactly the problem I want to avoid, to keep things manageable.

On 7/6/2025 3:27 PM, Caddiy via Discuss wrote:

What does "alternately" mean?

You make an animation that takes 10s to get a circle across the top.

You then need to spend the next 10s to get the circle across the bottom.

That's a 20s animation.

Print it onto film, so that we can talk about actual frames.  You need a
sequence of frames that run the circle across the top, and a sequence of
frames that run it across the bottom.  There's no trickery possible that
will somehow make the second time that you run the film be different
from the first time.  The film simply must continue until the elements
return to their original positions.

Now, to be clear, "original positions" does not quite have its obvious
meaning.  If you're animating a gear, each time you advance one tooth
you're back to something that looks the same, so you only need to
animate one tooth's worth.  If you put a mark on the gear, though,
you're back to having to animate the entire rotation.

Jordan Brown wrote:

What I mean is:

You make an animation that takes 10s to get one circle across the top 180°*,* after which it disappears for 10s.

You then need to spend the next 10s to get the other circle across the bottom 180°*, after which it disappears for 10s.*

Then repeat the sequence.

What does if($t < 0.5) mean in plain English? If $t is less than 0.5, then what? $t doesn’t go negative.

On 7/6/2025 4:12 PM, Caddiy via Discuss wrote:

That's a 20s animation.

Again, think of a loop of real film.  To get a complete cycle, you need
10s of a circle going across the top, and 10s of a circle going across
the bottom, and then back to the start.You can't play the same 10s piece
of film twice and expect to get different images on the second time
through.

Over the length of the animation, $t runs from 0 to 1.  $t is less than
0.5 for the first half of the animation, and is greater than or equal to
0.5 for the second half of the animation.

The "if" is a standard OpenSCAD "if".  It does whatever you tell it to,
when the condition is true.

For instance.

if ($t < 0.5)
	square(10, center=true);
else
	circle(d=10);

will be a square for the first half of the animation, and a circle for
the second half.

This will do exactly what you're suggesting:

if ($t < 0.5)
    color("red") rotate($t*360) translate([10,0,0]) circle(3);
else
    color("blue") rotate($t*360) translate([10,0,0]) circle(3);

But if you want it to take 10s for the red circle to go across the top
and 10s for the blue circle to go across the bottom, that's 20s.  Set
the FPS to whatever you like, and set the number of frames to twenty
times that - so perhaps 5 and 100.  That's what you must do if you want
the circle to change color, but if you wanted it to stay the same color
then all you need is

color("red") rotate($t*360) translate([10,0,0]) circle(3);

Jordan Brown wrote:

Thanks. It works fine, but it’s too damn fast for me. It’s the standard $t*360 speed.

So it seems $t is the time and 360 is the distance around a full orbit. Unfortunately it is not possible to give the 360° extra time for it to go slower.

Would it be possible with $t*180 to use an “else” statement to tell it to disappear when it reaches $t = 1, then start again at 0 after an interval of $t = 1?

On 7/6/2025 6:05 PM, Caddiy via Discuss wrote:

How fast it is depends on your FPS and your number of frames.

If you set FPS to 1, it will be slow.

Yes.

Yes, sort of.  $t*360 is saying "during the animation, vary from zero to
almost 360".

Pedantic node:  We've been saying $t=1, but it never actually
reaches 1.  It stops and loops back to zero one frame before $t=1,
so that a loop that yields the same image for $t=0 and $t=1 doesn't
have the same frame twice.

"Extra time" isn't really meaningful.  If you say "$t*360", it will take
exactly the length of the animation to make it all the way around.  It
can't take longer than that, because the animation is done when $t=1.

If you have something else that needs to move faster, multiply $t by a
bigger number - say, if you have another thing that needs to rotate
twice during the animation, it would be "$t720".  Look back at my clock
example, where the hour hand, the minute hand, and the second hand all
rotate at different speeds.  The hour hand is $t360, so it goes around
once during the animation.  The minute hand is $t36012, so it goes
around twelve times.  The second hand is $t1260, so it goes around 720
times.

If you have something that needs to move slower, then it needs to be
the thing that uses $t*360, and your original thing needs a larger
multiplier so that it will go around more times.

The animation only runs from $t=0 to $t=1.

There is nothing after 1.  That's the end.  Fini.  Then the animation
engine starts over, but it starts over from $t=0; absent random numbers
it will produce the same sequence of frames.

The universe begins at $t=0 and ends at $t=1.  You must set FPS and the
number of frames to control how many frames and how many real-clock
seconds that is.

(Actually, the FPS is pretty worthless in a lot of animations, because
once it takes more than a small fraction of a second to run your
program, the animation engine can't keep up.  What ends up mattering for
the final product is the parameters that you give to your video-creating
tool when you have it combine the frames.)

If it's easier for you to understand, you can do something like this:

FPS = 10;
FRAMES = 1000;
seconds = $t * FRAMES / FPS;

and always set your animation parameters to 10 and 1000.

Or more correct and less tightly tied to the parameters would be:

LENGTH = 100;
seconds = $t * LENGTH;

and set your FPS and number of frames so that frames divided by FPS is 100.

But for this kind of animation, where you have some piece of the action
that needs to make a complete circle, it's probably better to base
everything directly off of $t and thus what fraction of that complete
circle has gone by.  In the clock example, the hour hand goes around
once during the animation, and when we're 1/1000th of the way through,
the hour hand has gone around 360/1000 degrees, the minute hand has gone
around 12*360/1000 degrees, and so on.  I could base it on seconds,
but that only makes sense because it is a clock; if it was something
else going around then it wouldn't directly make sense.

You could work in seconds, but then you'd have to figure out how many
seconds it would be for your model to go through its full cycle, and
pretty much everything would cancel out so that you'd effectively be
back to working in that "fraction of a cycle" model.

Jordan Brown wrote:

That makes sense.

Animation goes in steps with certain intervals. What about generating a new image every 2nd, 3rd or nth step?

I am already at $t720. Unless I find a solution, I will need $t*1440. That will require a large number of steps and generate a large number of frames. But my video program can skip every second or third frame.

The clock example must be the worst case scenario! My engine also has three different speeds but they only range from half speed to double speed -  a factor of 4, but that’s bad enough if the range has to go from standard to quadruple speed.

Would it not be possible to introduce an interval between $t=1 and $t=0 equal to the time taken for a run from $t=0 to $t=1?

Or introduce some kind of a dummy run inbetween live runs?

I wish I had studied computer programming!