Andy Moorer is a VFX artist and TD working in the film industry.

Archive for proceduralism

In the “postSim” tutorial we made shapes out of strands by constructing arrays of point positions. Many ICE users, myself included, forget that there are a bunch of shapes provided already which can be used in this fashion. They are in the “Debugging” section, because arrays like these can also be used with ICE attribute display properties to create onscreen widgets (hint: …or to add points to a pointCloud…)

I’ve found the factory nodes to be quite handy for a number of things, but I wanted some other shapes of my own (such as a star and spiral)  - so I made them, as well as made some adjustments to what was already available (with some digging) to suit my personal preferences. Here is a scene with a number of them, each packaged as a compound.

Freebies!

And here’s the file (softimage 2013 322kb): ICE Debug Elements

While experimenting around with these elements as display objects, I made a “protractor” compound.

It’s of limited production use because of a current problem with how softimage displays these elements in a shaded or hidden line view, and because it wasn’t particularly designed as a tool… it just evolved while I messed around. But it serves as an example of how you can use the “Debug” nodes to create visual feedback (another good example of these debug elements is the factory “bend” deformer in ICE.)

Judicious use of these display attributes can make a packaged compound much more useful, as well as act as a handy jumping off point to make interesting shapes with strands etc. Enjoy! – AM

File (softimage 2013 270kb): example_ICE_protractor

The spiral compound plus the postsim tutorial makes a nice basis for a “cloud chamber” like wallpaper… :)

Categories : 3D Graphics, Examples
Comments (0)
Jan
07

Example – PostSim Needles

Posted by: | Comments (0)

During the making of the film “Barnyard,” which happened to be around the time ICE was being first conceptualized and built, a number of effects were identified which were a challenge at the time. Some of those effects became some of the first demonstration compounds later, presumably Helge and others still had those challenges in mind… making footprints in mud, falling leaves, rain/snow interacting on characters etc.

One effect involved a bunch of hay getting dumped on a character. At the time Hans Payer completed the effect via some nice scripting and syflex tricks. Now in ICE it is pretty easy, so when a thread about a similar effect was mentioned on the softimage list, and so soon after I had done the post-sim tutorial, I gave it a quick go. They basically asked for a way to use strands with the “falling leaves” compound. Here’s the result… while the collisions are not accurate the way RBDs would be I hope it’s food for thought at least. :D

Caveat: like similar tricks using the post simulation tree, motion blur is a concern… this is the kind of “quickie” effect that can often get you by, but hero shots would take a lot more effort, for instance if you had to see clearly the fibers bend and react to collisions, collide with each other, accurate mb etc. That kind of difference in the details is why feature film effects can get so hairy – often you can’t get away with simple cheats like this one.

File: softimage 2013 .scn, 237 kb

example_postSimNeedles

 

Categories : 3D Graphics, Examples
Comments (0)
Jan
07

Example – More value propagation in ICE

Posted by: | Comments (0)

Same basic deal as the prior example, but much simpler and using a weightmap. In this case a turbulence pretty much drives the whole thing.

The main appeal is that it’s a ‘lil planet. Everybody loves lil planets, right?

File: softimage 2013 .scn ~190kb

example_propagateValueViaWeights

 

Categories : 3D Graphics, Examples
Comments (0)
Jan
06

Example – Greeble Push in ICE

Posted by: | Comments (0)

SI-Community has a “resource dump” for scraps of stuff people want to share in an unfinished or flawed state for others to pick over. This “Greeble push deformer” I made a while back is IMHO a good candidate for such a bin, so I’m sharing it there.

BTW, if you don’t regularly visit SI-Community, why not? It, rray.de and the softimage mailing list are the heart of the softimage community. And vimeo:

It works fine, so why am I putting it in a “public rubbish bin” rather than releasing it with fanfare? Well, I’m not particularly proud of it lol. Here are some reasons why this isn’t awesome:

  • It’s a “push” style deformer, meaning it doesn’t create geometry it just deforms it. That kinda blows, it means you have to start with a very dense mesh. In fact, this is the main reason why I haven’t released the loads of terrain stuff I’ve got hanging around – I haven’t come up with a good way to make the geometry as I go and add detail only where it’s needed that isn’t too slow.
  • This is just worley noise hooked to a push deform structure and a repeat node. I was sure a zillion people were going to do it, in fact I’m amazed I haven’t seen this compound done better from someone else. Surely we have some Star Wars fans somewhere messing with ice?
  • I never bothered to add in a control to decrease the amplitude of the noise per generation. This would be easy enough to sort out but I never got around to it.
  • The deformer respects normals, but the noise itself is spatial, in other words it doesn’t “flow” along the surface, which would be nice. Note the sphere shape in the video, instead of looking like the death star it reveals this spatial, circular character of the worley noise.

But it’s hardly doing any good sitting on my hard drive so here you go – consider it an example of how to iterate a push deformer. Try turbulence instead of worley noise and it will look a little terrain like. Change the worley noise and you can make some crater-like looks. So it sucks, but in a kinda fun way. Hope it’s of use to someone.

- AM

File: softimage 2013 scene, ~3 MB

example_worleyGreebleDeform

Categories : 3D Graphics, Examples
Comments (0)

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

Categories : 3D Graphics, Examples
Comments (0)

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

Comments (0)

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…

Categories : 3D Graphics, Examples
Comments (1)

I’ve realized I have, over time, created literally thousands of fast test scenes and examples for coworkers using softimage ICE. Often for really cool stuff which never gets made. Most, like this one, are very simple. Some are quite complex.

Rather than have them sitting around where they don’t do any good, I’m going to try to post them on this blog whenever I happen to have a spare moment. I don’t have the time to discuss each one in detail in a post, but most are pretty self explanatory and should help give people ideas when they are stuck or just looking to play around. Most will contain compounds I’ve made but never taken the time to clean up and present to the public, being engaged in trivialities like earning a living or recuperating from making a living…

Is this useful? A lot of the people I work with are quite skilled and could easily achieve the same results themselves – I don’t want to try to suggest that I’m some kind of awesome guy for coming up with this stuff, or clog the collective internet airways and search engines with spam. So if you think it’s helpful, drop me a note. Likewise, note me if you’d just as soon basic stuff like this was kept to myself. :)

This first scene I’ll post was a quick example I made for an artist who needed a fast asset of this sort. Call it 3-minute lava. All we’re doing here is using ICE to turbulize a surface in respect to its normals and then using this deformation to drive a color blend on the objects material based on distances from a bounding center (I don’t remember why we needed it that way, it’s pretty primitive so maybe it was just fast. But there it is, as it was tossed from me to another artist.)

The file (Softimage 2013 .scn):

May
29

5 minute DLA for si-community thread

Posted by: | Comments (0)

Just a simple example for a SI-community thread where a user asked about creating something similar.

Categories : 3D Graphics
Comments (0)
Mar
01

Houdini 12 Released

Posted by: | Comments (0)

Houdini 12 is out, and it’s another impressive release. Congrats SideFX!

YouTube Preview Image
Categories : 3D Graphics
Comments (0)

Andy Moorer

Copyright © 2010 All Rights Reserved