Seamless animation

As discussed here I wanted to talk about seamless animation or loops. In preperation I listed some information regarding this from different places which can function a bit as a knowledge base on the subject:

First of all the Cartan Node library 3.6

Which contains the following animation nodes

• Apply_ramp: Use a curve as a ramp to change values during an animation
• Easing: Applies selected easing function to produce changing values over time
• Exponential: change values over time at an exponential rate
• Fade: adjusts alpha (0 to 100) of shapes or geometries
• Rearrange: Move a list of points or shapes to a list of target positions over time
• Reshape: Gradually reshape one polyline path into another
• Settle: Calculate values for a decaying sine wave
• Turtle_drive: Move a pointer around a polyline path
• Unwind: Unwind a polyline path into a line or segmented curve

And some other things:

• The tutorial for basic animation from the documentation
• The tutorial for the animation of subnetworks
• An explanation of basic animation
• An example of an animation loop

Floris,

Thanks for kicking this off. I hope we can make this a useful collection of posts about animation. I will add a few to the thread to help get us started.

First, a quick note about the animation nodes in my library...

I originally called this category "Change" instead of "Animation" because the same techniques used for animation can often be more broadly used to code the more abstract concept of change.

One example is gradation. The same easing nodes you use to control the speed of animation can also be used to control the shifting patterns of color in a gradation. Another example is controlling the rises and falls of a curve. Gradation is change across space; animation is change across time.

Some of the nodes in that category could arguably be placed in other categories instead. Fade, for example, can be used in contexts that have nothing to do with animation. But all of the nodes in this section have a "change" port that you can plug a frame node into. Here is the change port for each node:

• apply_ramp: frame
• easing: value
• exponential: value
• fade: percent
• rearrange: T
• reshape: T
• settle: offset
• turtle_drive: T
• unwind: T

For students of animation, a fun exercise would be too hook each of these into a frame node and use it to create a different animation.

ON SEAMLESS LOOPS

The first thing to observe about the art of making seamless loops is that there are situations where you DON'T want to make your animations loop seamlessly. Sometimes you want to emphasize the end of each cycle, not conceal it.

One example I did long ago was an animation about gradual change called Evolution. It shows an ape-like silhouette turning into a man-like silhouette so gradually that you are barely aware of any change - until the image snaps back to ape at the end of each cycle. That snap was the whole point:

https://www.instagram.com/p/COHMoZQney8/

But normally you do want to return to the beginning at the end of each cycle. Seamless loops are the temporal equivalent of seamless tiles.

One of the easiest and most pleasing ways of doing this is by using the wave node to create the gentle back and forth movement of a sine wave. Sine waves, being based on circles, always return to their starting point at the end of each period.

To use this technique all you have to do is hook your fame node to the Offset port of a wave node (set to type Sine), and set the period of an even multiple of the length of your movie.

For example, If your movie is 100 frames long, you can set your period to 100 and the output will fall, rise, fall again, and rise back to its starting point in exactly 100 frames. For more vigorous motion you can use any other even multiple of 100 for your period: like 50, 25, 20, or 10. I find that a period of 60 makes a soothing motion; if I use that I will make sure my movie runs for some multiple of 60.

There are countless other techniques for generating values that change and then return to their starting values. You can take any closed shape, feed your frame node into the T port of a point_on_path node, and then lookup the x or y value of the point traversing the shape's perimeter. Those x and y numbers will return to their starting values after 100 frames and will convert the inflection points of the shape into speed changes of the movement. For movies that are some multiple of 100 frames just feed the frame into a mod 100 node. For movies of any other length, just use a convert_range node to convert the length of the movie into a 0 to 100 T value.

Perlin noise produces charming and mysterious patterns that are ideal for animations. My noise node is great for making clouds that drift across a sky; just feed your frame node into the z port of my noise node.

But one drawback of Perlin noise is that there is no way (I know of) to evolve a pattern back to an earlier state - for the same reason that clouds in the sky never drift back into exactly the same pattern they had an hour before.

Even here, though, there are ways to create seamless loops if you try hard enough. One technique (which I haven't yet tried but which should work in theory) is to make a large landscape using Perlin noise, tile that pattern by reflecting it, then move a "camera" across the pattern until you cross the tile border and return to your starting point. (By "camera" I mean using a translate node to move a pattern across the window of the canvas.)

If this was done in a straight line you would see an obvious "rewind" effect as the clouds would move across the sky and then travel backwards. But with some effort and cleverness you could conceal this to some degree by taking a circuitous path across your landscape while also gently zooming in and out (using the scale port of the noise node) with a wave node.

A simpler way of looping Perlin noise is just to feed a sine wave into its Z port. If you render the noise directly you would see the clouds in the sky ebb and flow with the sine wave. But if you add in other effects you can conceal this effect. I used this technique on another animation long ago called "Movement in the Deep":

https://www.instagram.com/p/B_tldNhn3r6/

The noise is driven by half a sine wave that gradually falls from 600 to 0 and then rises back to 600. If you look carefully you see a flowing motion half way through the video that moves down and then reverses and moves back. But because of the way the noise was rendered into shifting angled bricks that are colored independently, the effect is not at all obvious.

There is much more to say on this topic. If anyone here has questions about how to make a particular animation seamless, I will be happy to help.

STOP ACTION ANIMATIONS

I've made many posts about animation over the years. I will share one here because it might help you think about animation in a different way:

https://forum.nodebox.net/t/15844206/forest-and-trees-movie-maker

The idea is draw each frame of your movie onto a giant poster and then use the translate node to jump from frame to frame. It's dirt simple; you just have to make sure each frame is the same size as your canvas.

I've never actually used this technique in one of my art pieces. It's not really necessary to draw out each frame ahead of time. But the underlying concept could produce some interesting effects if you used it to move your "camera" across the face of an image. Instead of a boring back and forth path, you could use my Hilbert node to create a space-filling Hilbert path. Or just overlay an ellipse and step through the intersecting frames. A normal photograph would probably produce seizure-inducing flickers, but a photo of sky or sea or leaves or fur or something with gentle gradations might be intriguing.

This technique might also be useful in cases where each frame is time-consuming to create. You could let your computer run overnight to create all the frames, save the poster as an SVG, then just import and move the camera to quickly edit and create the movie.

Just another idea to play with!

John,

Thanks for the replies.

I was triggered by what you wrote in to looping with Perlin noise.

“A simpler way of looping Perlin noise is just to feed a sine wave into its Z port. If you render the noise directly you would see the clouds in the sky ebb and flow with the sine wave. But if you add in other effects you can conceal this effect”.

I used the method with putting the frame-node onto the offset port-of a wave-node. I also used a waveform-node onto a ramp-node and connected that onto the z-port of a noise-node (see attached examples, don’t think I’ve posted these before). In this I tried to hide the reversal by changing the colours. But I am wondering whether there are other solutions.

In addition, what I find hard to track is to fine-tune the setting for a specific speed for an animation to loop within a certain duration of the animation.

For example: the wave-form has its settings, the apply ramp has its own, and the convert node the same. Let’s say I want an animation of 250 frames, I feel like I have to align all those settings. Or am I mistaken?

Exporting an animation costs time, so one can’t work that intuitively. Sometimes it takes hours before the result is visible and It turns out that for example the last frame is missing, because I made some error in starting at 0 or 1 with counting.

Any advice is appreciated.

Floris

Floris,

I like both of your videos. There is a noticeable back and forth swaying motion, but I think that works well in both cases, and the pacing seems just right.

You do need to align all your settings to the length of the movie (if you want it to loop seamlessly) - no getting around that. But they don't necessarily have to be aligned with each other. That is, each one needs to be a factor of the movie length, but they can be different factors. In fact, making them different can help disguise the reversal.

For 250 frames, you can have one factor repeating every 50 frames, another repeating every 125, and a third repeating every 250. Using lengths like, say, 240 or 360 gives you even more possibilities.

You also don't have to always use waves. You could use some function of the x and y values as you traverse the perimeter of shape, for example. Depending on the shape, this can create more complex movements that nevertheless return to their starting point. I sometimes use a character textpath for this purpose. This also lends itself to multiple factors: you can go once around the shape every 250 frames, or twice, or n times (or just use a different shape for each factor).

For Perlin noise you have two factors to play with: the Z value and the scale. The Z moves things back and forth while the scale moves things in and out. Depending on how you use the noise value to drive different elements, this can produce complex effects. And if the scale changes are based on a different factor than the Z changes, the reversal can become much less obvious.

When things get complex it becomes hard to get the pacing right. With experience you can get good at picking your fudge factors, but ultimately I think there is no substitute for making multiple renders until you get the overall pacing just where you want it.

As you said, this can become painful with long render times. One trick I often use is to use rough cuts to adjust my pacing. For pacing you can go lower res, maybe only use outlines of elements with no gradients, simpler versions of the elements, etc. This can reduce render times by an order of magnitude. Once you are satisfied with the overall pacing and ensure the seams match perfectly you can then crank up all the added fanciness for the final render.

One small trick I also use for seam checks is to flip back and forth between the final frame and zero frame (assuming I am rendering 1 to n frames). If the seams are right you should see no change between these two frames.

Hope that helps!

John

Hi John,

In regard to our discussion of seamless animation loops using noise values I asked the AI system Claude to come up with a python-script to be used in Nodebox 3 using the information provided here.

After some trial and error, failed attempts and different iterations this resulted in something that might be useful. In the provided file you can find the simplex noise script and an example with a custom node called simplex_noise. Claude also generated some information for its use and application:

the Simplex Noise Node takes the following input:

• x (type: float)
• y (type: float)
• z (type: float, default: 0.0)
• scale (type: float, default: 100.0)
• seed (type: float, default: 0)

So you can connect a grid node's x and y values to the noise node's x and y input

To create an animation with the z parameter:

• Add a frame node to the network
• Add a divide node
• Connect frame1.FRAME to divide1.value1
• Set divide1.value2 to something like 100 (controls animation speed)
• Connect divide1 to the z port of your noise node

The noise pattern will now animate smoothly as the frame advances, completing a full loop when z increases by 1.0. So this loop is seamless, albeit somewhat fast.

Floris,

This is fascinating.

I spent a little time learning more about noise. A very deep topic. There are many types of noise generators and toolkits with many options and settings. I had thought simplex was patented, but I see that patent expired a few years ago.

Your simplex node does indeed create seamless loops every time z increase by 1, but it's so jittery and seizure-inducing that I wouldn't want to use it for animations (without more intervening code). Each frame is wildly different from the next even when you zoom out.

When each frame differs so wildly the value of being seamless is reduced. It is genuinely seamless, but it's such a mad boil that even non-seamless loops are not that much different.

So I spent a little time looking at the algorithm seeing if there was some variable I could change to make it less frenetic. After some research I finally found that the only thing you can do is increase the Z value more gradually. This was the first thing I tried, but I didn't do it enough. Dividing by 1000 instead of 100 makes no noticeable difference.

But, it turns out, dividing by 40,000 DOES make a difference. You have to do something in that range to achieve a more soothing animation.

Attached is a zip file with my slightly modified version of your network. I didn't touch the Python module. All I did was:

• Change the canvas to 400 x 400
• Remove the bottom translate node to center the video
• Added minimum and maximum values (0 to 200) on the scale port, since the algorithm enforces that range anyway
• Changed the denominator in your divide1 node from 100 to 40,000

Attached are 3 short (100 frame) videos:

• The unmodified one shows your node just the way you shipped it
• The divide 40000 shows what happens when you slow the Z way down
• The divide and scale shows the same thing at 150 scale

I find the transisitions at 40,000 much more pleasing. But there are two obvious drawbacks:

• It's not all that different from Perlin noise
• It's no longer seamless

This seems to be a fundamental tradeoff. You might be able to make the Perlin noise animation seamless if you just sped it up by a factor of 400. But then it would be at a mad boil where seamlessness doesn't even matter very much anymore.

That said, I do think this node is interesting and could well be quite useful. I could imagine having a whole new wing of my library with different noise nodes. Before going too far down that rabbit hole, though, I would need to be convinced that the added variety and power is not so complex and confusing that no one would ever touch the new nodes.

I still think you could make Perlin noise based animations seamless with some of the other techniques I discussed above. It depends on exactly what overall effect you are creating and how long your movie is (100 frames may be too short a loop to achieve seamlessness). I might try to make a project to explore this further.

It would also be fun to explore other uses for noise, like world (island / continent) generation.

Thoughts?

Oh, one more unrelated thing I wanted to add to this general thread on animation...

I strongly recommend that whenever you save an animation project, you add a comment to your frame node with the recommended movie length. Keep it simple, just "1 to 100" or "0 to 250" or whatever.

I have learned from painful experience that when you come back to an old project, or try out someone else's project, you need to supply the From and To values in the movie dialog in order to export any movies. But unless these are written down somewhere, they can be VERY hard to figure out from the code.

Adding a brief comment to the frame node is a simple fix. I now do this for every animation project I make.

Floris,

I did a little more research and have a favor to ask...

Could you ask Claude to generate another version of your Simplex Python Node, this time with 4D noise? It should be just like your current version, but based on a call that takes X, Y, Z, and W (in addition to scale and seed).

4D noise allows you to create 2D patterns and then advance through them not just linearly using the Z dimension, but in a circle (or any other 2D path), using both the Z and W dimensions. This is the key to making noise animations that loop seamlessly.

The simplex algorithm was designed to support 4D noise, and most implementations include that option. But every Python port I found had dependencies including Python 3 (instead of 2.7 which Nodebox runs on) and external libraries like NUMPY. What is so impressive about your Claude-generated module is that it runs on plain vanilla 2.7 Python with no dependencies.

If you can produce a node that takes X, Y, Z, and W, I can wrap it in additional Nodebox code to make seamless animation more intuitive.

Thanks in advance for anything you can come up with!

John

Hi John,

Thank you for your replies and your suggestions. Some take-aways from that I want to note for a potential follow-up: note the length of animation in a comment and maybe use a (wave) visualization to track the (value) synchronisation between different moving design elements. The going between between first and desirable last frame of a loop I've already applied a lot. Especially in this last experiment in regard to the attempt for a '4d noise field'.

I provided Claude with the earlier Python script as an example. And a txt.file with the documentation on custom nodes.

It took about 15 (!) iterations. Attached is the best result. Just some things I found while using this workflow:

• Sometimes the conversations become too long, especially when the script gets more complex and/or the iterations become too much, and you'll have to start a new chat (I don't know whether this is caused by a lack of bandwidth or server delays)
• Sometimes I've reached the limit of questions/prompts for the day and I had to continue the next day.
• Therefore it is useful to careful number each prototype (both the script and the custom node)
• It is also advisable to continuously update the prompt to a more specific wording (in the case you'll have to start over)
• Sometimes, after a couple of iterations, it seems to 'forget' that it should work within Nodebox and it'll seems to revert to regular Python
• It takes some effort to prevent the custom node to get too complex, when it comes up with more extra arguments for inputs.

What follows is a selection of the final conversation I had with information regarding the prompts, the results and the use of this node:

Prompt: Can you generate a Python 2.7 script for a simplex noise for use in Nodebox 3 based on the documentation and the example provided.

**1. Make arguments for X and Y, which are points coordinates - keep them separate.

2. Make an argument for Z. Z is an integer and controls the animation of the evolution within the noise field and has a frames-node as input.
3. The evolution of the noise field should loop seamlessly after a certain amount of frames which can be controlled with a separate argument. Call it W.
4. Add an argument to scale the noise field, which has 100 as a default.**

Reply: This simplex noise generator for NodeBox 3 implements all your requirements:

It processes X and Y coordinates separately, with support for both individual points and lists of points.
The Z parameter controls the animation evolution within the noise field, designed to work with a frames-node input.
The W parameter controls how many frames it takes for the noise field to loop seamlessly.
There's a scale parameter with a default value of 100 to control the noise field's resolution.

Prompt: The animation visibly reverses. I would like to have the impression of a continuous evolution, is that possible?

Reply: I've improved the animation approach in the simplex noise generator. Instead of using sine and cosine functions that create a circular path (which causes the visible reversal), I'm now using a linear progression through the z-dimension of the noise field.

Here's what I changed:

Simplified the animation approach by directly using the frame progress (z % w) to create a continuous evolution through the noise field.
The z-value now progresses linearly through the noise space, creating the impression of continuous movement without any reversal.
The W parameter still controls the length of the cycle, but now the animation smoothly transitions from the end of one cycle to the beginning of the next.

Prompt: If I divide the frame number, the animation slows down, but the loop also takes a longer time to repeat. Can you somehow separate the 2 settings?

Reply: I've revised the script to properly separate the loop cycle length and animation speed:

The w parameter still controls how many frames it takes to complete a full loop cycle.
The new speed parameter (default value 1.0) controls how fast the noise pattern evolves within each loop cycle:

Higher values (e.g., 2.0, 3.0) will make the noise pattern evolve more dramatically between frames
Lower values (e.g., 0.5, 0.1) will make the evolution more subtle and slower

The implementation now uses a circular path through the noise space with a radius controlled by the speed parameter. The larger the radius, the more distance is covered in the noise space per frame, resulting in faster visual evolution.
The loop cycle is still determined by w, so regardless of the speed value, the pattern will repeat exactly after w frames.

This approach gives you the best of both worlds:

You can control how long the loop takes with the w parameter
You can independently control how much the pattern changes between frames with the speed parameter

The animation will be continuous and seamless, with no visible reversal at any point during the cycle. The default speed is now 1.0, which is more moderate than the previous implementation.

I am wondering whether there are more scripts (from Nodebox Live for example) that can be ported to Nodebox 3 in this way. That would open up a whole lot of possibilities (a good packing script for example would be nice).

Floris,

Bravo!

Thanks for sticking with this through 15 iterations. In addition to creating a powerful new node, you have also demonstrated a proof of concept that could lead to many more new nodes.

I have taken your original node and made some modifications. I then wrapped it inside a subnetwork to create an even simpler node for general use.

Details:

I discovered one problem with your node: unlike the previous version, there is no seed input. Even worse, the noise was not fixed, but would instead fluctuate every time you relaunched or hit Reload. This means that you could perfect an animation and then find it totally changed each time you played with it.

So my first goal was to add a seed port like your previous version had. I was tempted to ask you to ask Claude, but decided to give you a rest and see if I could modify the Python code myself.

I was finally able to do this, but it was painful. My Python skills have atrophied and Claude's code was a tad tricky. When I tried passing the seed directly the way the previous version did, it worked but ran 20 TIMES SLOWER. Yikes. But with another hour of head-banging I finally found a way to get both seed and speed.

To solve this problem I had to use a global variable for the seed (so I could still use the class instance without having to pass anything), and force the code to always read in the X and Y values as lists. This also required a few changes on the Nodebox side but the end result works just the same and is just as fast as your version.

I made the following changes to the Python code:

• Added comments crediting you and Claude and noting my subsequent changes
• Imported the seed function from random
• Added a global variable for the seed
• Added seed initialization to init_rand_seed
• Added myseed parameter to main function call
• Added to comments describing the new myseed parameter
• Added code to update global variables inside main function
• Changed code to always treat X and Y as lists; removed other option
• Removed additional simplex_noise functions which were not being used (and probably would not have worked)

I also made some changes to the Nodebox node:

• Changed name from simplex_noise_4D (which didn't fit) to simplex4D
• Changed range on X and Y to List
• Changed output of node from Value to List
• Added myseed port
• Added comment for node

Finally, I wrapped the simplex4D node inside a subnetwork to make the ports a tad more user-friendly:

• The outer node is called noise_circle which will land it right after the existing noise node in my library and make it easier to find.
• Added the same node comment explaining the functionality and Python module requirement.
• Instead of forcing users to do lookups each time, I just provide a single port for "points". The subnetwork does the X and Y lookups automatically and passes those along.
• Renamed the z port to "frame".
• Renamed the w port to "frames per cycle".
• Changed speed's default from 1 to 100 and divide by 100 before passing on to the internal speed port. This is consistent with scale and also makes it easier to enter fractional speed values (e.g. turn knob down to 70 instead of typing .7).
• Renamed myseed to seed.

I also cleaned up the demo a little:

• Removing the earlier noise nodes and other superfluous nodes
• Increased canvas to 600 x 600
• Reduced pixel size from 12 to 10
• Increased the resolution of the animation to 60 x 60
• Put "1 to 250" comment on the Frames node, not the noise node where you had it. My custom is to always keep that comment in the same concise form and always place it on the frame node. I also make sure I only use one frame node and place it near the top. That way, both the frame node and the attached comment are always easy to find.

The result is a slightly beefier animation, 3600 pixels instead of 900. In addition to the screenshot and demo, I have attached a sample move:

• 250 frames (10 seconds) at 250 frames per cycle
• Scale at 150
• Speed at 100
• Seed = 1

NOTE: Unlike the Perlin noise node that everyone has been using till now, noise_circle returns values between 0 and 1, not -1 and 1. Depending on how you use the noise values in your project, you may need to make this adjustment if you replace noise with noise_circle.

A lot to absorb, I know, but I wanted to get this all documented before I forgot what I did.

Floris, please let me know what you think of these changes and if you think noise_circle is ready to add to the library.

Everyone else, please take this node for a spin and try using to create some generative art of your own. Although it is designed for animations, you can use it for anything requiring random noise. If you don't want the noise to loop just set the frames per cycle to a higher value that your total number of frames.

Kick the tires, try changing all the parameters, and report back with any questions or suggestions.

If this looks solid I will make a separate post with the official documentation. Then maybe we can talk about what else to do with this raw AI power.

Thanks again, Floris!

Hi John,

Thanks for the reply and the improvements. I think it looks solid. I did a test run and seems to work well. So I think this could be another addition to the library. (You misspelled your name in the comments in the script by the way.)

• Claude often made only an input for points. I asked it every time for a separate x and y, because the original had it. But I like to limit the amount of controls as much as possible as well. So with this, and more descriptive labels, it’s more user friendly.
• I wanted a seed input as well. And I do have some prototypes containing it. But often it seemed to get confused on what moving variable ought to be randomised, since the field itself is animated (z) and the movement across it as well (w). So it’s great you were able to add it.

Floris

Floris,

Thanks. Thanks also for spotting that type in the Python comments. Fixed.

I share your ambivalence about hiding the separate X and Y ports behind a point port. But I think we both agree it's a good trade-off: one less port and no need to separate out the X and Y by hand - which is what would happen 95% of the time. And if you do need to access them separately, you can just use a make_point node to turn that one port back into two.

And you can also access the sinplex4D node directly if you want. That's one of the nice things about wrapping a direct code module node inside a Nodebox subnetwork: you get the best of both worlds.

Actually I would have slightly preferred exposing just the Z and W ports as pure numerical inputs and building the circle myself in Nodebox. That would have allowed loops in shapes other than circles. But the way you and Claude made this, treating W as cycle length and automatically calculating the correct radius for the given speed, is much simpler for end users and what the vast majority of people would want to do anyway.

Finding the right balance between simplicity and flexibility is one of the most important and enjoyable parts of node design.

Speaking of loops, on further thought I think I would like to rename this node as noise_loop instead of noise_circle. That's a better fit with looping animations and seamless loops.

I plan to try making some art with this thing before publishing it, just to make sure it works well in the trenches. I encourage everyone else to do the same.

I just posted an animation created by the noise_loop node on Instagram:

https://www.instagram.com/reel/DIYgm96RXkD/

So far I am quite pleased with this node. I can see many possibilities!

It works fine as a replacement for the earlier noise node (with visible reversal), without editing much else. As as test I reworked an older animation

I just published the official version of noise_loop here:

https://forum.nodebox.net/t/8646513822/noise-loop-node

I also started a conversation about Nodebox and AI here:

https://forum.nodebox.net/t/8646811032/nodebox-and-ai

I suggest we move further AI explorations to that thread.

Floris, John (and maybe Claude),

I just wanted to drop you guys a line and say, that I enjoyed seeing that simplex noise loop node come to life and honestly, thank you so much!

I tried to give it a little bit of spin but it got out of hand and became this <a title="" href="https://va.media.tumblr.com/tumblr_ql7ohwodeX1vv589e_r2_720.mp4">type specimen poster</a> that I enjoyed the hours I put in, thanks again to you both.

(ps. there is a touch of film grain after the png export, other than that it's all your magic.)

A

Abdu,

You are most welcome.

That poster you made is fascinating. If you feel like it, I would enjoy hearing you say a little more about how you used noise_loop to make it.

It seems like every morph from one character to the next follows the same rhythmic motion of jerking and twisting and distorting (even though the actual shapes are different each cycle). So I'm guessing the "shape" of that motion came from noise_loop somehow. Is that close to the truth?

I always enjoy seeing your creations. I'm so glad that noise_loop can be part of it.

J

Sooo glad you liked it, John.

Thank you for your kind words,

and YES, of course you are right!

Just for the sake of practice to see if I am able to explain, I'll try. I simply used the noise_loop to get noise values of the each points of shapes that creates the letters and added those noise values to their original coordinates so I can harness the organic flow of the perlin's noise. I was trying to using that for a long time when I first saw the founder of the Nodebox first embeded Perlin's code and shared it with you in the forum and also lately been using in <a title="" href="https://nodebox.live/embed/abdupala/dro/pp?autoplay=true">Nodebox Live</a> a lot.

SO, noise_loop was such a great tool for this kinda morphing from between different shapes. It is seamless alright, like big time but I wanted to use that seamlessness in extreme levels so i can jump to one another. In order to that a lot of sin and sawtooth waves have been throwed for getting everything I can from your loop parameters.

I will of course share the .ndbx file when I'm finished solving some issues. This is just a mere example of what you can do with it. I'll investigate a much much more in depth later in the way, intuitively ofc.

I wonder if wouldda been possible to get 3D-like sphere effect from the circular movement from the noise. I mean a noise map that contains different levels of scale, let's say the center is more rough scaled or the other way around than the outer rims...

I dunno if this makes any sense at all.

a

Hey John,

Just so let you know, I did tried to respond to your kind comment yesterday I think, but it is not shown here for some reason. Maybe it got into the spam folder, again?

Please let me know if it's there

a

Abdu,

You were right: your earlier comment did land in the spam folder for some reason. Highly annoying, I have restored it.

Thanks again for your response. I am still just beginning to play with the new noise_loop node myself. There are many possibilities. I made something yesterday using it to create little amoeba-like creatures with undulating boundaries.

I'm not sure exactly what you meant by sphere effects. But by feeding a range node into the Z port instead of the frame node you should be able to generate multiple planes or evolving noise that you could use to form 3D still objects like spheres (and then project them back in to two dimensions). Noise_loop is optimized for circular 2D animation using 4D noise which is all we really need for a 2D program like Nodebox. But for people animating 3D objects in Blender or whatever, there is such a thing as 5D noise that could animate 3 dimensions of space with 2 dimensions of time.

Sorry again about the spam folder; it seems to like you for some reason. But keep on trying to share your stuff - I really do admire it.

John