vfx

Fibonacci, Phi, and Nature

There are a billion discussions of the Fibonacci sequence, phi, the golden section etc. So I’m going to let you browse the wonderful web and largely find out about it for yourself (try here), with only this brief summary…

The Fibonacci sequence is a series of numbers such that the last two numbers of the sequence added together result in the next: 0,1,1,2,3,5,8,13… ie: Fn = Fn-1 + Fn-2.

If you take the ratio between any two consecutive numbers in the fibonacci sequence, they increasingly converge towards a single value, 1.61538 (memorize it!) which is called the “Golden Number” or Phi: Φ

This ratio is found throughout nature, as well as classical art, mathematics etc. It crops up in an amazing number of places. A logarithmic spiral in which points of the spiral are Φ units apart after a quarter turn is called a “golden spiral”, for instance, and can be found in seashells, seed pods, flowers, pinecones and as I said before, lots and lots of websites. If you’ve had a certain amount of coffee, this video might be illuminating:

am_DandilionWeb

Other artists using ICE have put out tutorials and compounds relating to these spirals, browse around  (hint I’m one of them.)

Recently as I fiddled around I came across an interesting point about these kinds of distributions that caught my attention: they are a very efficient way to pack particles evenly on a surface. This is an important point to an effects artist, because not only is a large part of this job mimicking nature, but distributing points efficiently on surfaces lets us maximize the number of non-overlapping particles we emit.

So, I built some compounds, first to calculate phi (or simply return it as a stored constant, depending on the accuracy needed.) Another to convert phi into angles in degrees and radians (the “golden angle”), and finally I took these and made an emitter. Hooray, it indeed did allow me to emit a sphere of particles packed efficiently, and even better since I didn’t have to use a “generate sample set” it allows millions of particles to be emitted much faster than simply emitting particles from spherical geometry, and without any resolution-dependance on the LOD of a polygonal sphere. And this “phi” distribution has a nice, natural look.

 

phiDistribution

Here are the compounds, enjoy: ICE_phiDistribution

 

The single best post a VFX artist can ever read.

I am a big fan of Polynoid. Ever since their first images of cybernetic snails came out I’ve been hooked on their often-dark blend of art-meets-tech imagery.

Fabian Pross of Polynoid was, for a while, maintaining a very cool blog (come on Fabian, post new stuff!) One post in particular puts into words a critical concept I and many others often try to get across to newer artists – the importance of avoiding simulation where possible.

Simulations usually don’t quite achieve what you want them to, visually. The trap people fall into is to try to force a behavior out of a simulation. You end up making endless iterations while the setup you’re using grows more and more bloated and slow. A single directoral change becomes a nightmare. You lose control and the limitations of your setup starts to dictate the look.

The solution is to create what I think of as “deterministic” solutions – setups which change over time, but in very strict ways you specify. That’s one of the things I was trying to get at with the “post simulation” tutorials, the benefit of offloading much of the look outside of what is simulated.

Even skilled vfx artists fall into this trap with some regularity. I can’t say how many times I’ve seen production scenes which have grown bloated to the point of containing hundreds of forces and collision objects just to try to achieve a simple effect. You can’t afford it. A simple directoral change blows the whole thing apart. Stop. Take a deep breath. Don’t go over that cliff. Simulate judiciously, in small doses, only where you have to.

Simple simulation + deterministic stuff for a complex look = control.

And control is what makes a VFX artist, in my mind. Anyone can pull levers until they get a nice result out of fumeFX. But to achieve brilliant results which are new or spot-on to what is needed in prodution, you have to have control – be it in fumeFX, ICE, Realflow, Houdini or whatever. And one of the best ways to achieve control is to only simulate where you have to, and keep it simple when you do.

Fabian puts this idea into words better in this post. Even if the techniques he uses here are specific to ICE, the underlying message and workflow is the same everywhere – avoid simulation to gain control and speed.

Sparta

Even when you use simulation, who says that you have to stop there? Bake it and use it as an element you shape further or build on. This concept is really powerful. A good example of this idea in practice is demonstrated by a little DCC-agnostic tool called Sparta. Simulate, then shape the results.

Post-simulation and Softimage ICE – extras

To make a point that the underlying concepts introduced in this simple tutorial are far more important than the simple look of our example, here are some images which derive from the simple parametric circle equation discussed. The scene used to make the anaglyph is below. This isn’t rocket science stuff, this is novice level ICE… and much of it applies to realflow, thinking particles, maya or whatever. Cheers – AM

 

 

And here’s the scene used to make the anaglyph version, with comments throughout (softimage 2013 ed, ~200kb) spirographEmission_anaglyph

Post-simulation and softimage ICE (part 3 – vectors and modulo)

So, we’ve made a strand circle which rings our original point positions from the simulation, now let’s make those circles align with the rotation of the simulated particle. In practice this is very, very simple. Just insert a “rotate vector” node after you calculate the coordinates on a circle for the strand points, and then use the particle orientation as the input rotation.

Ok, that was nice, but why did it work?

Point positions are vectors. Vectors are displacements:

This is one of the simple but critical concepts that is the real purpose for me writing this series of posts, because it’s a foundational way of thinking which lets you come up with solutions to problems every day.

What is a point? It’s a place, within a space. A particle can have all kinds of attributes, like color size and orientation. But a point is just a position, it only has a single value, a vector (x,y,z). In a manner of thinking, a point is a vector. The vector which describes a point is a direction and distance from the origin. It’s a displacement from that point of reference. When you talk about “global” and “local” space you are talking about different frames of reference, different points of origin from which to draw a vector describing points.

So, what we really did when we calculated an array of strand positions on a circle was make an array of vectors. Hence, rotating those vectors is really the same thing as rotating the strand point positions to match the orientation of our original particle. Points are vectors, they are offsets (or displacements) from an origin. And ICE is very, very good at doing stuff with points vectors. You can call these manipulations vector math if you want, but that in itself doesn’t make it beyond your average artist, who like ICE are also very, very good at manipulating points. If you are an artist you already have an intuitive grasp of vectors! You just need to define some terms, so that saying stuff like “rotate a vector” translates to the visual adjustments you do in your head day in and day out.

Seeing stars… and why modulo is so handy:

Ok, cool. We have a bunch of strand rings centered and oriented where our simulated particles were. Let’s make the rings star shapes, as a way of talking about another useful technique in ICE (it’s useful all over in fact), making patterns via the modulo function.

Ok, a digression first – some housekeeping. By now you’ve realized this isn’t one of those step-by-step makes-a-scene tutorial, I’m discussing more and glossing over a lot of the details you may need to actually plug all this together. I really should have provided a sample scene earlier, I don’t want you focusing on plugging nodes together, the whole point of this is the underlying ideas. So here you go. A sample scene with nifty comments and stuff. If all you want is a scene that will make circles and stars, there you go. And it was made with an educational license, even. But if you want the ideas used so you can make all kinds of other stuff, well then dear reader, read on.

The modulo function is just an instruction to divide two numbers and pick out the decimal remainder of that division. If you feed a linear sequence of numbers (like the index of an array: 0,1,2,3… call any of these numbers “n”) into the modulo function, you get a value counting up between 0 and 1. You can use this to identify every “n’th” item in your list. In fact if you crack open ICE’s “every n’th particle compound etc you will basically see exactly this.) If you can do things every “n’th” time, you can make patterns. Think about it. Braiding hair, knitting, drawing a dotted line – making almost any pattern involves counting and every “n’th” count doing something differently. Modulo is how you do that kind of thing in ICE (and elsewhere. Hey, realflow has an ICE like system now. And it works in scripting too. This math stuff pops up everywhere. The big secret is this – it’s just a way of looking at things you probably already do really well.

I’m a visual thinker so when I was first learning about modulo I had to scribble on a napkin, with results something like this:

All a star shape is, is a pattern where we take every other point on our circle and change it’s radius. Now we know how to find every other point from our list (the array) of strand positions, so we just change the radius of the formula we used to make the circle for those points. And you get a star.

Cooooool.

Ok, so just one last part to this tutorial, and a brief one – how to take the single circles we made and, using the earth-shaking power of ICE and the post-simulation region, turn that result into a lot of circles: all different and making little atom things like we see in the example video. And in fact, the example scene here already shows you how, so we’re not even going to do much besides discuss it and crack bad jokes. Cheers. – AM

The file (softimage 2013 educational, 1.2 mb)

strandPostSimOffset_tutorialPart4

Post-simulation and softimage ICE (part 2 – strands)

 

Ok, so we’ve talked about the post-sim region, and showed an example. Just what did I do in there?

Strand basics:

Strands are one of my favorite features of softimage ICE. They are really cool. While it’s beyond the scope of this tutorial to get into everything there is to making strands, here is some foundation… Strands are essentially a bunch of per-point attributes telling ICE how to draw the resulting strands. These attributes contain information about color, orientation, number of points in the strand and so on. In our example, the most important of these to us is the strandPosition array. It is an array, one per each particle, in which each strand points position is stored. This is what we’re going to manipulate. Make a simple particle simulation in ICE, and then add a post-sim tree. We’re going to work in there…

Create a strand for each particle:

There is a compound in ICE called “create strands,” which we’ll use here. I’m not a big fan of this compound, it gets the job done but if you get into ICE strands much I advise building your own. At a minimum, I suggest opening up the “create strands” compound and looking around, and then make a single, simple change. See the compound in there called “calc strand ratios?”  Plug it into a new port of the big “set data” node in there, and name it “self.strandRatio.” This is an array which assigns each strand point a value ranging from 0 to 1 along the length of the strand. Think of it as a replacement for a “u” value of a curve, it gives you an idea where on the resulting curve a point is. Take your resulting modified “create strands” compound, plug it in, and set the number of strand segments to 20 or more. (Note: depending on the size of your display you may need to click on images to see them without cropping.)

Drawing circles:

There are a lot of ways to describe circles mathematically, but for our purposes we are interested in getting cartesian coordinates (x and y values for each point on the circle). Without getting into the math suffice it to say a parametic form of the equation for a circle you were exposed to in school (x² * y² = r²) is as follows:

xr cost

y = b + r sint

Where (a,b) is a center point, r is the circle radius and t is an angle ranging from 0 to 2Π (or 360 degrees).

Remember that “strand ratio” value? It ranges from 0 to 1 on the length of the strand… meaning if you multiply that by 360, you get the angle (t) for each point on the strand. So, to draw a circle with ICE strands on the x/z axis (like a hula hoop) you get this:

And the result (on a single point) looks like this:

Add this to the particle point position and you get this:

Note that I took the entire “calc strand ratios” compound (from inside “create strands”) and used it here, rather than getting the strand ratio directly where we saved it earlier. You can do it either way, and it’s slightly slower this way where the strand ratios are calculated over and over per frame rather than just being looked up from where we saved it…. but it saved some room in these screen shots. ;)

Next steps:

Now all we have to do is move the actual particle at the center to close the circle. Since we’re in a post-sim tree, moving the particle around doesn’t invalidate our original simulation, it just makes the change for rendering – as far as the “simulation” ice operator is concerned the particle hasn’t moved. So, let’s make the point position the same as the last point on the strand. To get that last point, we can “pop” it from the strandPosition array. Pop just takes the last member of an array, so it’s a handy way to get the value we want in this case. So we get the strandPosition array, pop the last value, and use that as our new point position.

Pretty simple, isn’t it? In the next post, we will adjust the circle to match the particle’s orientation, and then we’ll use this whole setup to create a series of concentric rings around each simulated point. Cheers – AM

 

Plus… seeing stars…

Post-simulation and softimage ICE (part 1)

“What happens in the post simulation tree stays in the post simulation tree”

A quick review: ICE operators are evaluated differently depending on where they reside in the construction history (also known as the operator stack or modifier stack.) When an ICE tree is under the modeling region it is evaluated every frame unless a simulation region exists – if it does, it is evaluated once. An ice operator under simulation is evaluated every frame, and all data is updated every frame. In other words, changes persist and appear in the next frame – if you move a point, in the next frame that change is reflected. And when an ice operator is in a post-simulation region, it is evaluated every frame but changes are discarded. The “lower” regions evaluated first, then each region “above” it in the explorer, like so:

This is very, very useful. You can have an entire simulation going in the simulation region, and then do stuff to it prior to display. For instance, you could cull out all particles which aren’t visible to the camera to reduce cache size and speed evaluation. You can calculate per-particle lighting prior to rendering it, to control lighting entirely within ICE. Or, in the example below, you can move points around without altering the original simulation.

Example: Strand shapes

Here’s an interesting “look” done entirely with strands in ICE. A typical particle simulation has been used as input for an ICE operator in a post-simulation region, which uses the simulation as a basis to draw many circular strands.

First, I made a very basic particle simulation:

Then, in a post-simulation tree, I drew the strands.

… So you can see that for this effect the bulk of the work was done in the post-sim ICE tree. I use the point positions and orientation from the simulation as a center point around which I add new particles with strands. In my next post I’ll show exactly what I did, but the point I’m getting at here is that things don’t have to end with merely a simulation. You can get into some very cool stuff by considering each frame of a simulation (or a cached result) as a starting point. You can deform your entire simulation, rig it to a character, light it, or perform housekeeping tasks like camera frustrum culling. You can even treat the entire simulation as a single unit and scatter it – they sky’s the limit.

A quick note about motion blur:

When I wax rhapsodic about the post simulation tree the most frequent argument I run into is that moving particles around in a post-simulation operator invalidates motion blur calculations. This is true. Motion blur is based on the velocity of a particle, which can be considered a vector from the previous point position to the current. In the post simulation operators, the previous location is unavailable… it’s like a dog’s sense of time, only what exists “now” has any meaning. So, you have to do some extra work if you need motion blur. Basically, you store the previous point position into a user variable which can be read by your post simulation ICE  tree and use that information to calculate not only how you wish to move a particle, but how you moved it in the prior frame as well. From this you can calculate a valid velocity to pass to the renderer for motion blurring. That sounds awful, but it’s not really that bad. (Still, it would be handy if the devs gave us an easier workflow than this, for instance could they store and give us access to post-sim point positions and velocity or something?)

Next:

We will look at creating the offset strand shapes – circles, stars etc. Stay tuned!

Vampires and the Presidency

Some early reviews for ALVH. I grew quite fond of this film while working on it, I’m hoping viewers will have a lot of fun seeing it. Ok, ok I know… It was a ridiculous premise that worked well in the novel but which may simply be ludicrous on screen. And I know, there were people who didn’t like the campy stuff, they retiming or color, etc etc ad infinitum. But it’s a vampire film, not a period drama. Have fun with it.

There is innovative atmosphere galore: this doesn’t look like much of anything we’ve seen before. Mostly, though, the overwhelming impression I’m left with is sheer delight, that Abraham Lincoln: Vampire Hunter is so very much better than it has any right to be.

Full Review

Here’s another…

But the film’s title tells the whole story and sets the stage for its over the top action and freight train like pace. It’s called Abraham Lincoln: Vampire Hunter…Let’s have some damn fun. There are a lot of amusing nods to historical events and characters that anyone with a high school diploma will find entertaining. But it’s the overall feel of the film that I loved most. Beside’s Walkers spot on Abe, it’s a very dark and violent film.  Initially I was sure the studio would want to sell as many tickets as possible to a film that had vampire in the title and slap a PG-13 rating on it. However, Fox, trusting a successful R-rated director in Timur, held nothing back and the film is better for it.  It’s incredibly violent and features vampires in the correct and demonic light with which they should be seen.  It’s not overly campy but it’s just enough to smirk at and you’ll find yourself saying “Really?” only a few times. The action is far too much fun and grabs you from the first axe swing till the last twirl. Abe’s axe is the new bending bullet.

Full Review

And some viewer reviews from early screenings look promising…

So I saw the first ever premier of the movie. First of all don’t let the title scare you, this movie is an action packed, fun flick. The best part of the movie is definitely the Action scenes, the special effects are awesome. There are some very innovative scenes, and great cinematography. The director used a lot of cool angles with a bunch of slow mo special effects. The plot is decent and there are no lulls, the action picks up right when the movie needs a boost. The vampires look great as well, especially Erin Wasson as Vadoma… gotta love hot evil vampire chicks.

Viewer Reviews

Overall I was very impressed, having never read the book I did not really know what to expect. Acting was good, nothing Oscar worthy but no poor performances….the action was absolutely fantastic. It was over the top, fast paced, bloody, and very well done. If you don’t mind seeing vampires getting hacked, slashed, and bashed to death in a wide variety of ways, you’ll enjoy this movie.

Viewer Reviews

I’m looking forward to seeing the public reaction to ALVH in the theatres: go check it out and let me know what you think. :D

Abe Lincoln: Vampire Hunter is Awesome

FearNet has a nice post on Abe Lincoln, Vampire Hunter. Here’s my favorite bit:

– This movie puts vampires back where they belong, and that’s as bad guys and not    heartthrobs; who should be beheaded with an axe and not kissed by tweens. That’s what you can expect. Badass vampires getting treated like the killers that they are.

I can’t tell you how awesome working on this one is. By far it’s the most creative and enjoyable project I’ve worked on in years. It’s a really fun film.

From filmofilia:

Vampires. Axes. Lincoln. What's not to love?

“Visionary filmmakers Tim Burton and Timur Bekmambetov (director of Wanted) bring a fresh and visceral voice to the blood-thirsty lore of the vampire, imagining Lincoln as history’s greatest hunter of the undead.” 

Starring Benjamin Walker, Dominic Cooper, Anthony Mackie, Mary Elizabeth Winstead, Jimmi Simpson, Robin McLeavy, Alan Tudyk and Rufus Sewell.

If you want to see more cool official pics from the film, try this article at bestmoviesever. Good stuff!