Jordan Brown wrote:

I think I’ll stick to what I know and leave the fancy stuff for others to put in the Users Manual. It will certainly be an improvement on the previous version.

Thanks for sharing this, Jordan.  I learned a lot!

Jon

On 1/21/2024 11:01 PM, Jordan Brown via Discuss wrote:

On 1/22/2024 1:09 PM, jon wrote:

You're welcome!  (And do look at other Advent calendar entries; there's
interesting animation in several.)

Linear and circular motion are fairly straightforward.  Multiply $t by
the distance to be moved, or multiply $t by 360 to walk around a circle.

For anything else, you need to somehow map the 0-1 range into the
behavior that you want.  That might be linear, or non-linear, or
discontinuous.  Interpolation is your friend.

The really hard part is that stuff like this is like Legos.  Each part
is small and, on its own, largely useless.  It's all in how you put them
all together - and there are an infinite number of ways to put them
together so it's hard to just give somebody a step-by-step procedure.

Jordan Brown wrote:

Except that the linear motion is unnatural i.e. not to be found in the real world.

children();
for (x = [ 
[10, -$t*20+10],
[-10, 20*$t-10],
[$t*20-10, 10],
[-20*$t+10, -10],
])
translate([x[0], x[1]])
square(5, center=true);

difference()
{
offset(0.1)
square(20, center=true);
offset(-0.1)
square(20, center=true);
}

The above looks good with 4 squares, but remove one or give it a different colour and you see the Ilyushin. So how can a square be prevented from jumping back at the end of its travel and move off at 90° instead?

• https://imgur.com/a/5N20EP6: “This post may contain erotic or adult imagery.” Disappointed, couldn’t find any.

• Fascinating stuff in the Adventskalender!

• Looking forward to other peoples’ additions to Animation: $t in the Users Manual!

On 1/22/2024 8:10 PM, Caddiy via Discuss wrote:

Well, yeah.  If you want the end of your animation to connect seamlessly
to the beginning, the final image has to be the same as the first.  (Or,
really, more subtle than that, since you'd want the last frame to be the
frame before the first one, not the same as the first.  I think
maybe OpenSCAD handles that for you by never setting $t=1, but I'm not
sure.)

For the three-square case, you've got to generate four times as long an
animation, because you have to include the missing square crossing all
four sides.

See a solution below, and some more commentary below that.

Don't know what to tell you.  I don't have it marked "Mature".

--- Here's a solution for the "missing square" animation ---

// Divide the animation into 4 segments.
// i is which of the four segments we're in.
// t2 is where we are (0..1) in that segment.
// I don't know whether $t is ever exactly equal to 1.
// Just in case, suppress that with the min().
i = min(floor($t4), 3);
t2 = $t4 - i;

// Order is important.  The first is motion across the right side,
// the second across the bottom, et cetera.
positions = [
[10, -t220+10],
[-20t2+10, -10],
[-10, 20t2-10],
[t220-10, 10],
];

// The segment (i) says which of the sides doesn't have a square.
for (j=[0:len(positions)-1]) {
if (i != j) {
translate(positions[j])
square(5, center=true);
}
}

// Draw the track.
difference()
{
offset(0.1)
square(20, center=true);
offset(-0.1)
square(20, center=true);
}

--- Here's a solution for coloring the squares differently ---

// Divide the animation into 4 segments.
// i is which of the four segments we're in.
// t2 is where we are (0..1) in that segment.
// I don't know whether $t is ever exactly equal to 1.
// Just in case, suppress that with the min().
i = min(floor($t4), 3);
t2 = $t4 - i;

// Order is important.  The first is motion across the right side,
// the second across the bottom, et cetera.
positions = [
[10, -t220+10],
[-20t2+10, -10],
[-10, 20t2-10],
[t220-10, 10],
];

colors = [ "red", "green", "blue", "black" ];

// The segment (i) says which of the sides doesn't have a square.
// Note that the colored square here plus the difference below add
// up to a preview problem, because there are different facets (including
// negative objects) at the same place.  Lifting the squares just a hair
// fixes it.
for (j=[0:len(positions)-1]) {
color(colors[(4+i-j)%4])
translate(positions[j])
translate([0,0,0.001])
square(5, center=true);
}

// Draw the track.
difference()
{
offset(0.1)
square(20, center=true);
offset(-0.1)
square(20, center=true);
}

Additional commentary:

These are just one way to solve these problems.  They extend the
original illusion; each square moves on only one side, and an external
mechanism dynamically hides one of the squares or gives them the right
color.

You could also track one square all the way around by having key
locations and interpolating.  Here's that style, with the additional
tidbit of having the square get bigger and smaller during its travels.

xTable = [
[ 0.00, -10 ],
[ 0.25,  10 ],
[ 0.50,  10 ],
[ 0.75, -10 ],
[ 1.00, -10 ],
];
yTable = [
[ 0.00,  10 ],
[ 0.25,  10 ],
[ 0.50, -10 ],
[ 0.75, -10 ],
[ 1.00,  10 ],
];

sizeTable = [
[ 0.00, 2 ],
[ 0.50, 7 ],
[ 1.00, 2 ],
];

x = lookup($t, xTable);
y = lookup($t, yTable);
size = lookup($t, sizeTable);

translate([x,y])
square(size, center=true);

// Draw the track.
difference()
{
offset(0.1)
square(20, center=true);
offset(-0.1)
square(20, center=true);
}

Jordan Brown wrote:

I think I’ve got the last one: interpolation means you can allocate position values to incremental values of $t. Could probably be used to show the flow of a fluid in a pipe. Needs further study.

Don't know if this is already mentioned but one function in particular I find to be incredibly useful.

T=awk "BEGIN{print $COUNT / $TOT_STEPS}"
W=awk "BEGIN{print (1 - (cos($PI * $T))) / 2}"
The above written in UNIX shell script.

In OpenSCAD language the "W smoothing function" can be written like so:

w = (1 - cos(180 * $t)) / 2

This causes 'w' to go from zero to one, as does $t, except that w accelerates very gradually at the beginning and then it decelerates very gradually at the end. The speed of how fast 'w' is changing at the beginning and at the end is zero. The nice thing about trig functions is that you can do a derivative however many times you want, and they will still be smooth. They are very natural-looking to the eye.

Here is an online tool to help you figure out these sorts of functions: https://www.desmos.com/calculator

Sent with Proton Mail secure email.

On Monday, January 22nd, 2024 at 5:21 PM, Jordan Brown via Discuss discuss@lists.openscad.org wrote:

I am just wondering, if openscad could not do the same, what awk is doing
for you ?

Especially the desmos homepage is a great  find for me today.
They do not only have a great graphical calculator, but also a 2D
geometry engine, a 3D graph plotter and even an SDF solver.
I like it and will definitely bookmark it!

On Tue, Jan 23, 2024 at 9:02 AM neri-engineering via Discuss <
discuss@lists.openscad.org> wrote: