Humanity has presumably gazed at the stars long before the invention of speech and the concept of numbers…

But it took until the middle of the last millennia till we really understood our own place within the cosmic clockwork.

Checkout the Kopernikus Planetarium!

In 1704, George Graham and Thomas Tompion build a mechanical, heliocentric illustration of the solar system – a copy was made for the Earl of Orrery – hence the name “Orrery“.

Recently my fellow worker Philipp Althoff introduced me to those fascinating devices and we decided to build one.

As orrerys naturally show a scaled version of the solar system, high precision is vital for the device will quickly start to become inaccurate.

Philipp did an outstanding job measuring, modeling and texturing a model that also is completely parametric, so we could freely scale its polygon count for use in Unity 3D.

Klaus Hünig from Astromedia.de was so kind to support us with plans and data of his “Kopernikus-Planetarium“, a beautiful orrery construction kit.

While I did my best to research and calculate the exact orbits, directions and pivots, Mr. Hünig pointed out my errors and helped to refine the model.

Conclusion

The result is a 5MB heavy, animated Unity 3D version of the Kopernikus orrery by Astromedia.de.
Orbits and scales are accurate, the time scale able.

Finally we also produced a screensaver installer (WIN) and Philipp did the finishing touch on the browser version by composing the celestial background music.

Hope you find it relaxing.

There are those popular structures we all know and love because they simply look fascinating from every angle – like the Sierpinski triangle, the Pythagoras tree or the Menger sponge.
Generative geometry is one more proof that math is beautiful no matter how basic.

Recently I stumbled upon a new pattern that is also phenomenally simple but produces rather complex shapes – the “Binary Kite”.

I first saw it in Mikael Hvidtfeldt Christensen’s ‘Structure Synth‘ – an ingenious tool for exploration of generative 3D structures.

Basically it’s a 3D array of randomly black/white colored cubes that slightly scale(linear) and rotate(noise) per iteration on one axis.
What makes it look so interesting is that each items transformation matrix is subordinated to its predecessor on that axis.

Initially, I played around with the kite in Unity 3D but quickly discovered that it can´t be animated at high iterations.


So I fired up C4D and wrote a simple Py4D generator.

The results

I did end up with this gorgeous picture of a 30*30*500 cubes kite (5400000 polygons) (fullsize):

Here is a closeup from the same viewpoint (fullsize):

Last but not least I rendered this short animation of a 5*5*150 kite growing:

Want to render your own kite with even more cubes? Grab the scene file here.

Hint:
Remember to uncheck “Optimize cache” in the Python Generator´s properties if you want to animate the parameters.

Conclusion

While Structure Synth is awesome, Cinema 4D and Py4D are a great way to visualize generated geometry too as Cinema’s render instances enable you to work with millions of objects.


Cheers

Surely you have already heard of Conway’s cellular automaton – the Game of Life.

For those who haven’t, it’s a simulation of cells interacting with their neighbors by following a simple rule set on an infinite, two dimensional grid.

So let’s add a dimension -> view the game of life in 3D!

The Game of Life has become famous not only in theoretical computer science, for it is Turing Complete, generates the most interesting patterns and is easy to implement.
In flash it can be done in ‘one line’ of code by means of a convolution filter.

So since 1970 the Game of Life has been explored by almost every programmer, it’s no surprise its “Glider” pattern became the official “Hacker Emblem” in 2003.

Customarily it’s visualized by a 2D representation of the board/grid – however, it can be applied to 1D and 3D space as well.

While I find 3D versions/rule sets to be interesting too, there is a much simpler way to lift the game into three dimensions that also generates more beautiful patterns:
Simply plotting the (visible) game grid´s state over time on the third axis perfectly visualizes the process and generates amazing shapes… or at least very interesting greebles

Why Unity?

The only issue is the amount of cells to draw – visualizing a small 10*10 field over 100 generations already means handling up to 10k cubes or sprites.

And I had an even higher amount in mind, so flash wouldn’t get me anywhere this time.

First I thought about building a standalone app, then using Processing or Py4D…

There it hit me – Unity! As long as OpenGL isn’t native to the web, Unity 3D is definitely the best way to deliver intensive 3D games/apps via the browser.

As Unity offers C# as scripting language I immediately feel at home. Unity 3D reviewed in one word: Awesome!

The draw call issue

But there is always a stumbling block hidden somewhere.

Since I am generating a lot of cubes (cells) on every frame, unity has to do a huge amount of draw calls – one for each object.
The frame rate on my machine (Q6600, GF8600) dropped right into the basement.

The simple solution to this issue was to generate the complete generation of cubes and to fuse them to one single mesh using Mesh.CombineMeshes.
Normally this is done on startup – for the exact purpose of reducing draw calls – and I thought it could also be used at runtime for this scenario.

As objects are limited to 65k vertices, it wasn’t possible to merge the complete scene into one mesh, but that might have quickly become too time intensive as well.

So finally I was able to animate/display more than a million vertices.

Conclusion

The app now draws a 50*50 grid over a time of 200 generations – press space to reset the game and seed a new field of life cells.

Admittedly, it takes a lot of resources – a graphic adapter with at least 128MB is essential as the simulation might end up with 1.5 million vertices.

Hope you get to see some interesting patterns – have fun!

I haven´t written about Py4D for quite a while now…

In the meantime, Maxon has first announced a cooperation with – and now the acquisition of Sebastian Rath´s praised python implementation for Cinema4D.

So finally – Cinema4D meets Python!

Let´s celebrate with some cool experiments!

If you are new to this blog or Py4D – a short introduction:

Py4D enhances C4D with a standard Python interpreter that provides access to the C4D SDK and allows to easily code platform indepentent scripts and plugins that control or extend C4D.

Basicly the same as COFFEE, C4D´s own scripting language, but Py4D has two major advantages:

• It follows the C++ SDK more closely and implements it further than COFFEE does.
• It is a easy to pickup, widely known language with a huge community and tons of existing code and librarys.

While C4D is a mighty tool in itself, this powerful scripting interface enables the user to work with external data, automate processes or build his own tools.

Being more the C++ type when it comes to plugin development and C4D, I enjoy being able to solve small problems just by hacking a few lines of code into the script manager.
I also prototype most of my plugins in Py4D before I start developing in C++ – it´s just more convenient.
The step of compiling for every test takes much more time in the long run.

So here´s the meat:

Four simple examples how to have a good time with Py4D and some particles…

Everyone requires C4D R11.5, the Thinking Particles module and the actual version of Py4D.

Py4D has been through some changes since the open beta started, so I took the time to update the scripts I published in the boids, and strange attractor posts and included them here.

Click the images for a preview.

1. Stars4Py4D

This is a Py4D port of the Sagan experiment I did in flash <- check out this link, it´s fun

A good and simple first step with particles - position vectors get parsed from a CVS database and from a galaxy of suns… “My God. It’s full of stars!”

Hint: this example might be the best to start with, as it includes comments – the others don´t, because they use pretty much the same pattern.

Just download the package, load the scene and change the path to the CSV file within the “file” user data field of the Py4D Tag.

2. Phy4D

A very simple adaptation of a 2D “physic engine” – works only with spheres.
The direction of gravitation is animated to make this a little more interesting.

Have a look at the preview video and scene file.

3. Boids

This is simply a revival of the Py4D Boids post – same beast, but updated to the Py4D release version.
The script creates a flocking boids swarm, that behaves according to the rules outlined by Craig Reynolds.

Checkout this video from Sebastian and get the scenefile.

4. Strange Attractor

Again just the script from the original strange attractor post, but ported to the final SDK.
View the final rendering and the original post – you can use the Strange Attractor Finder to locate your very own, chaotic attractor!

Here´s the scene file.

Conclusion

Python and Cinema4D are a great team and Py4D is THE alternative to COFFEE.

I hope this gives everybody who is interested in Py4D and controlling particles, a small head start, some inspiration or at least something fun to play with


Thanks to Sebastian for suggestions, support – and of course Py4D.

Cheers!

In his TV series “Cosmos”, Carl Sagan travels the universe in a “ship of the imagination”.

Uninfluenced by the laws of physics, “perfect as a snowflake, organic as a dandelion seed”, this vessel carries him between galaxies, stars, and planets.

And now you can cruise the cosmos too!



Recently I watched cosmos again and remembered how that sequence fascinated me as kid.
The sheer scale of the distances involved blew my mind. It still does today.

The concept has been revisited by many popular movies and media (Man in Black, The Simpsons…) and is always the same – the camera enters the universe, our galaxy, solar system and finally stops on earth – sometimes entering the microcosm, like the DNA of a cell.

Years ago I experimented with something like a pyramidial image to archive this effect in flash, unfortunately the result didn´t create the feeling of depth that I had hoped for.

But flash has advanced in those years… as I wrote before, in the strange attractor post, Ralph Hauwert and Joa Ebert have published some astonishing code that renders nearly half a million particles in real-time!

First I decided that I would work with real data – otherwise this would become just another “random stars / noise flying at you” screensaver.

But after some research I learned that the actual distance of nearby stars (called “stellar parallax”) is not always known, so that most models and databases project stars onto the inside of a virtual sphere.

Finally I found the HYG database – “a subset of the data in three major catalogs: the Hipparcos Catalog,the Yale Bright Star Catalog (5th Edition), and the Gliese Catalog of Nearby Stars (3rd Edition)”.
It contains about 120.000 stars, many including their parallaxes and conveniently cartesian coordinates, so I saved the step of calculating xyz from right ascension, declination and distance – like I had to with other databases I tested.

The CSV file got stripped of all additional data aside from the positions with a simple parser – that got it down from 20 to 4MB – still too big for my taste.

So I added the Fzip library to Joa´s AS3 only version of Ralph´s experiment, parsed the position vectors, scaled them and got my first view on our galaxy – breathtaking.

Scaling, controls and a simple clipping where swiftly implemented and everything was set for the voyage to the stars…

Tribute – “A Glorious Dawn” displaced

While watching the result, an idea struck my mind:
As the z-axis movement of the camera or the zooming into the szene is done by simply scaling the particle positions, its obviously possible to change their parameters in realtime…

I remembered my displacement experiment with papervision and quickly added a color parameter to the particle class, loaded an flv video and compiled this:

“A Glorious Dawn” live rendered to a displaced point cloud

Conclusion

It´s possible to handle an awful lot of particles with flash, even more if haxe/alchemy – inlining gets involved.
As the displacement experiment shows, the dataset can even be dynamic!

And hey – these are real stars, so this is science!

Hint: turn up your gamma adjustment.

Smart PRS is a Cinema4D tag that allows to record position, rotation and scale of one or multiple objects to key frames.

This is especially useful for all, who want to bake Thinking Particel setups and don’t own the MOCCA module.

Take a look at the demonstration Video.



Recently I tried to use the AfterEffects export Option from Cinema4D to pass a simple particle animation to AE.

Unfortunately this didn´t work out – the issue is that all animation capable export formats/plugins rely on key frames, and objects animated via Xpresso/Thinking Particles are most times not even present in the timeline as they get generated as “Particle Geometry”.

While this can be easily fixed by creating them manually and linking the particle positions to them, it´s still impossible to export that animation without key frames.

Cinema4D offers the option to “bake” certain motions to key frames, but not from simulations.
Actually there is a plug-in called “Cappuccino” within the MOCCA module that allows this, but if you are not into character animation, chances are you don´t have it handy.


SmartPRS makes those animations export-and editable by recording them as key frames while the simulation is running.
After that, the Xpresso setup can be removed from the scene and the animation edited or exported.

The plug-in even allows to capture the position of an object that gets moved in real-time by the mouse.

About three decades ago, pixels where as big as toasters – and mostly green.

Today we have millions of them to deal with, and the terms anti-/aliasing are part of our daily live and every time an image is scaled, it gets interpolated to keep those bad “stairs” away from our eyes.

But what if the source image is aliased in the first place?

Checkout the demo of SmartAA!



While upsaling is the most common cause of aliasing, there are images that are naturally aliased – for example images from a 3D render engine.

Of course there are many ways to antialias cg images when generating them – for example by rendering to a higher resolution than targeted and downscaling the result (FSAA)- or by rendering and merging four slightly offset variations.

While this is as computational intensive as it sounds, modern GPU´s can handle this task rather easily as they have their buffers and hardwired magic to do so, but still it’s not uncommon to come along aliased images in the world of computer graphics.

So is all this material “useless” or can an image that has never seen any antialiasing, or has been upscaled with the nearest neighbour method, be reconstructed?

In fact all that modern imaging software does when rescaling an image is reconstructing its pixels to fit the new dimensions – most times with a bicubic filter.

SmartAA is a bicubic BC-spline reconstruction filter for PixelBender.

Its 3×3 kernel gathers all neighboring pixels of the one to reconstruct and weights them with the Mitchell-Netravali(german link) filter.

In essence, this means that each pixel is modified by the average color of its surrounding friends.
While “average” being the wrong term here as the influence of each pixel is determined by the spline curve of the Mitchell-Netravali filter.

This eliminates those hard, “stair-like” artifacts of the aliasing by visually “softening” or unsharping the image.

However this is not simply a destructive blurring effect but a reconstructive analysis of the source “signal”.

There are many known filters that do this hard job – it´s not easy to reconstruct information that was partly lost (or never there in the first place).

Thus all of them suffer of the same issues – the result always shows some artifacts.
Mostly it’s a visible unsharping, anisotropy or the so-called “ringing“.

In general bicubic reconstruction methods create the best results.

Among the various possible filter methods the windowed Sinc(Lanczos)- and Mitchell-Netravali filter are chosen the most as their output is considered to be the best mix of the inevitable unsharping, anisotropy and ringing.

Just for the record: there are “better” solutions, the so called “adaptive” or “smart” filters that try separate methods on edges, fills and other structures.
They are particularly useful when working with sequences of moving images (video) but again slow to compute.

SmartAA on the other hand is a quite simple implementation of the M.-N. filter and runs blazingly fast when run on the GPU – producing about 70 redraws per sec on a 1024*768 image.

Unfortunately it´s not nearly as fast on the CPU.
If you have a rather slow machine, you will have seen the demo struggling to keep a 24fps framerate, so its just! that bit too slow to to antialias the pixelated output of a flash based C64 emulator.

That would have been cool… would love to see something like that.

I kept it flash compatible anyway – still there might be applications.

Its a matter of personal reception, but to me the M.-N. filter looks better on videos as the inbuild “smooth”-method.
Anyway – flash video has been criticized enaugh for high cpu usage so lets not make things worse

Also: like any reconstruction filter it won´t work in any given scenario as there are some natural and some specific limitations.

So what can SmartAA do and what not? Here is a feature/limitation list:

Features:

- Works with Photoshop, After Effects, Flash
- Supports alpha channel
- Is real-time

Limitations:

- Does no up/down scaling – just reconstruction of anti aliasing
- Is scenario specific – for example text will often look strange
- works only with artifacts in the same pixel space.

Let me elaborate on the last point:

As SmartAA takes only neighbouring pixels into account it isn´t able to reconstruct aliasing effects that span over greater distances than 2 pixels.
For example if an image exists of 4*4 pixel blocks of the same color, those blocks would get rounded on the edges but will still be visible as rounded blocks.

But it works ideal on sources like aliased output from a render engine, or images that have been upscaled x2 with the nearest neighbour method.


Conclusion:

Aliasing should be fought before it ends up within an image as there are more sophisticated methods to keep it from emerging than to reconstruct it after the damage is done.

But sometimes it´s inevitable and if you are looking for a simple but effective way to get rid of that ugly blocks within an image or video – SmartAA will do the trick.


Download:

Grab the Shader here and use it with Photoshop (Pixel Bender Plugin needed), After Effects or Flash!


Hint:

Try to add a sharpen filter or better an unsharpen mask to the result to counter the blur effect.
Don´t forget to use the width/hight properties – SmartAA will work without but there will be artifacts on the upper- and lower right corner.

I hope this is helpful to anyone out there and would love to hear some comments or ideas.

Cheers!

The flame wars are on!

CEOs, CTOs, platform evangelists and users are fighting the war of the worlds out there.
It´s HTML5 vs. Flash, open vs. closed, H264 vs. OGG, desktop vs. mobile, truth vs. lie.

Lets first calm down with this nice audio visualization before we dive in…



Since Steve´s presentation of the iPad and recent statements from him and Apple it´s clear that they are not going to support flash on their mobile devices.

This has triggered an ongoing debate on Flash, HTML5, browser plugins and web technology in general.

Unfortunately the whole discussion is rather uncivilized as there are a lot of people involved who make their living from those technologies and standards – and even more who use them on a daily basis.

So much has been written on this topic during the last two weeks… much was impulsive, exaggerated or plain wrong misinformation while few statements showed greater insight or were just watered down by irony and harsh language.





So I am not going to take part in this discussion with a detailed view on the technology involved or why one standard is superior to another etc.. sorry, but there will be no rant

Why?

Because this has already been done beautifully by others and because – it doesn´t matter.

What really matters is to get things done! To create content and to deliver it to the widest possible range of audience.

As a developer I don´t have the luxury of choosing my tools based on personal favor. I have to work with what’s best suited to achive the desired result – be it HTML, Flash or Silverlight or whatever may come along.

As a user however I have that luxury – I vote with every click and my wallet for and against technology that I consider to be worth my time or money.

So there is no point for these two groups of people to lash out against each other or certain technologies.
Of course this doesn´t apply to CEOs, CTOs or platform evangelists – it´s their job to influence the aforesaid groups on their opinion.

So what will all this mean for the web? Almost nothing.

The web has always been based on open standards while innovation was often driven by the “big boys” like IBM, MS, Apple and many others.
Finally this innovation gets adapted to open standards – as well as the economy assimilates ideas from the open source world.

And all this is healthy!

Sure – like in nature, it sometimes seems cruel and unforgiving, but whatever survives in the end may stay… just to be replaced by its successor if it doesn´t evolve.

And in the end everybody in this constantly changing ecosystem wins:

Companies get to sell their products and to rant about their competitors, developers get jobs instead of finally being replaced by generators, and users get more and more for their money.

So I am glad we live in a world with more than one operating system, programming language, browser, or pair of socks to choose from.

It´s the freedom “to choose” that makes the web/live so exciting.

Cheers!



PS: About the audio visualization experiment in the opener:

I wanted to do something with Five3D for a long time now and well – here it is.
You can load your own mp3´s via the right click menu.

Relighting is an interesting method that is often used in video post production pipelines.

Given the vector of its surface normal, it is possible to calculate the brightness of each pixel by a pseudo 3D lightning system.

Checkout the demo of SmartReLight!



As the ‘object space’ – or ‘material’ normal’s have to be known, relighting is mostly used within the post process of CG generated images or videos.

It’s a convenient way to archive great lighting and gives the artist most control as he can tune it in real-time without having to re- render the footage for every adjustment.

As you can see from this example, the complete lighting is done by the shader using only a color pass and the object normal’s:

This implementation is fairly simple as it doesn´t support reflections and refractions like Normality , but its fast and does the job – and what better way to get through the last cold days of the year than playing half an hour with Pixel Bender?

It’s also possible to relight already lighted sources to some extend, by not using the color- , but an already phong- shaded pass:

You can download SmartReLight here and the source of the demo including the shader here.

Compiling PB shaders at runtime

Last but not least a short but very interesting story:

Recently I was asked if it was possible to compile a PB shader at runtime.

Given it some thought – why not?

And as it turned out the hell of a chap Nicolas Canasse already took care of that matter.
There is also already an AS3 port by James Ward.

All the best for 2010 !

Screen Space Ambient Occlusion or SSAO is a method to compute an approximated AO pass in real-time!

This is done by using the depth information of a 3D object or scene that has been stored from the Z-(depth) buffer of the renderer.

Go ahead and try the interactive demo or see a video example!

The technique was introduced 2007 at Siggraph by Crytek Studios and is becoming an often used feature within next generation live-3d engines or cg/video post applications.

After playing with the ray traced inside-out AO and having to realize that it´s not quite doable with Pixel Blender, I turned to SSAO and quickly got some nice results.

In short it´s all about importance sampling.

SmartSSAO looks up the depth information of 12 surrounding samples and checks if they get occluded to average the AO value.

The disadvantages lie in the nature of SSAO being “screen spaced” which means that it can´t take objects from the off into account, and the result has to be blurred to reduce the inevitable noise.
Also there is no ray bouncing, so classic AO is visually superior – but hey… who can argue with “real-time”?

View another video of the buffer and the solo SSAO pass without/with blurring.
Please note that those strange looking anomalies on the buddahs arms originate from the badly ranged zmap I produced in a hurry.


To sum it all up:

SSAO makes it possible to have AO in places where it normally isn´t possible – e.g. real-time engines (yes – even for Flash/Papervision), or within a video post process.

All that’s needed is the Zbuffer of a 3D rendering.

You can download the Shader here or get it packed with an AFX example.


Hint: As said before, the SSAO pass needs to be blurred in order to clear out the emerging noise – but don´t overdo it, as the blurring will “bleed” the result over to unwanted areas.
This could be targeted by a special SSAO blur filter that would again have to take the depth map into account.


Click here to see this screenshot as video

Update:

I feel like I should adress the X,Y-offset params of the filter which can be used to tweak the “shadow direction”.
“Shadow direction” in quotes as (SS)AO is all about indirect lightning so this is a real “tweak” or an unrealistic param – which I thought might come in handy in some cases.

I was asked if the shader was performant enaugh for flash – and even if it looks a bit ugly codewise as I had to get rid of a loop – it surely is.

So I updated the package and made this small interactive flex demo :

Be sure to try unchecking “color SSAO?” and “show SSAO?” to get an impression.

You can grab the source here.

Update 2:

The filter now features an additional sampling radius parameter which controls the dispersion and allows to adjust it to the desired level of detail – this should also make it more useable for papervision.

I hope this little experiment will be of use to somebody out there and would love to hear any suggestions.

Since some years the idea of harnessing the power of modern graphic cards for 2D/3D applications has become more and more popular.

Today we find GPU support in many CG applications like Photoshop or After Effects.

But first the fun part: Watch a video raytraced with PB and AFX!

The chaos group is even working on a GPU based real time version of Vray – a widely used modern GI raytracer.

In fact GPU shading is often more performant plus it quasi ‘adds’ an unused/inactive processor.

One could argue that Pixel Bender doesn´t quite fit the term as its mostly run in software mode (on the CPU) – for
example when executing a PB shader in Flash or rendering it with AFX… for now.

But PB is still young and the prospect of being able to run it within multiple adobe platforms (Flash,PS,AFX) is very compelling.

When I saw Tom Beddard´s PB port of Keenan Crane’s genius julia set tracer, I remembered that I had planned to get into PB GPU raytracing once I got around Mike Welsh´s PB raytracer.

So I spend some time with it, created a scene similar to ‘The Eye’ and added viewport controls as well as anti aliasing.

The result can be viewed here.

Rendertime was 3:10 on a Q6600 for 4700 frames.

And here is the modified shader.

I also fiddled around with adding an inside-out AO (ambient occlusion) pass but wasn´t able to get satisfying results.
It even almost fried my GPU in the process so in conclusion it’s doable but sadly not practical.

Strange attractors are fractals that emerge at certain, sensitive parameters within the three-or more dimensional phase space.

They are are researched since the early 70s and strongly related to the chaos theory as they allow to watch the transition from chaos to order/geometry.

Good things first: see the result and try the chaotic attractor finder!

The 3D visualization of a strange attractor is quite resource intensive as points race around the attractors on chaotic trajectories – so it needs many iterations or particles to see a shape emerge from that chaos.

There are already some great flash experiments so I turned to Cinema 4D and PY4D as an advanced renderer would easily allow to raytrace and shadow the results – and to calculate even more particles of course.

This small PY4D script creates a strange attractor that Dr. Clifford Pickover had published 1990.

Unfortunately I had to discover that the bottleneck at C4D wasn´t the rendering of vast amounts of vertices but the allocation of many particle objects.

I managed to render a maximum of 50.000 particles with the R11 before C4D outmaxed my systems ram (4GB).

Thats less than a sixth of what can be rendered realtime with flash.
Admitted that comparison is unfair for many reasons, still… there is a point.

But with the new R11.5 release Maxon introduced render instances to C4D allowing now to calculate up to millions of particles – depending on the system.

Sadly I was limited to 300.000 points so I seeded the attractor parameters and rendered four transparent animations that could be combined to a 1.2 million particle video.

The preparation time for each frame was ~1min while PY4D took less than a second of that duration to perform five sinus/cosinus operations for each point.
Rendering itself took about five seconds per frame (CPU:Q6600).
Also its worth mentioning that the viewport can actually draw more particles that C4D is able to render.

It would be interesting to see how for example POVRay or Blender would perform when faced with this task.

If you are interested you can download the szenefile here.
(Remember to activate render instances in the PShape node of the XPresso tag when using the R11.5).

Update:

I already knew that 3D Studio Max and Softimage could handle several millions of particles but i was surprised to hear that Maya seams to have similar problems like C4D.
I also gave Blender a shot and managed to preview and render over a million with ease.

When I learned that you can actually identify strange attractors using the Lyapunov exponent and found John Holder´s programm ‘lyapdemo.c’, I took a few minutes to port it to AS3.
So I can find more fascinating attractors for further experiments (most likely with blender) and you can use it to generate parameters for the PY4D script aswell.

Sebastian Rath´s PY4D is a new, alternative way to script with or to code plugins for Cinema4D – without COFFE or C++ – but in Python.

The current beta (v0.9.0001) already makes a fine impression and proves itself easy to get started with.

This video shows a little script that was adapted in a twinkling and controls the particles of a TP-Storm to behave after the three flocking boids rules.
Don has rendered a much prettyer version of the dummy above.

You can download the C4D-scene here or view the scriptfile.

This little 3D experiment is called Metabubbles as it´s behavior and look are quite similar to those of real metaballs.

In fact it is just PV3D ViewportLayers with the blend-mode “add” that produce those gooey effects when balls with a similar z-depth pass each other – “old school”.

The cpu-load is quite high but the result is as psychedelic and relaxing as watching a lava-lamp…

Sit back and take a time out …

With CS4 Adobe introduced Pixel Bender to Flash, After FX and Photoshop. Pixel Bender allows to easily write and test filters witch are finally compiled to bytecode (Flash) or machine code (AFX).

For the new version of Smart Normal, its sobel-edge shader got portet to PB – making it blazing fast. Its even possible to use it for realtime shading.

Want to use Smart Normal directly within After Effects or Photoshop (CS4) ? Just grab it from Adobe Exchange and drag it into your plugin-directory.
(Photoshop needs the Pixel Bender Plugin).