Examples

Minor Pipeline Tools – Logging Distance

3D Graphics, Examples / By

There is an awesome thread on the softimage list where the small pipeline enhancements softimage users tend to accumulate in their personal collections are being discussed. In it I vowed to share mine to the community as a whole over time on this blog. So here’s the first one… a little python script I keep in a custom menu, which writes a log (as an anotation in the explorer) of distances between objects.

File (<1kb): LogDistances.py

#—————————————- # Log Distances between 2 objects # 2011 A Moorer #—————————————- xsi = Application xsiRoot = xsi.ActiveSceneRoot lm = xsi.LogMessage root = xsi.ActiveSceneRoot def SelectionCheck(): sel = xsi.Selection if sel.Count <= 1: lm(“Select two objects.”,4) return False if sel.Count >= 3: lm(“More than two objects selected.”,4) return False else: lm(“\nLog Distance\n————————“,32) return True #———————— #Distance Between Centers def ctr_dist( objA, objB ): from math import sqrt,pow # Thx to Alan F for this function Ax, Ay, Az = objA.Kinematics.Global.Transform.GetTranslationValues2() Bx, By, Bz = objB.Kinematics.Global.Transform.GetTranslationValues2() return sqrt( pow(Ax-Bx,2) + pow(Ay-By,2) + pow(Az-Bz,2) ) #———————– #Annotate Distance def annotate( nDist ): if xsi.ClassName(root.Properties[“MeasuredDistances”]): prevText = xsi.getValue(str(root.Properties[“MeasuredDistances”])+”.text”) lm(“Logging new distance measurement…\n”,32) xsi.SetValue(str(root.Properties[“MeasuredDistances”])+”.text”, str(prevText)+nDist, “”) else: oSet = root.AddProperty(“Annotation”,0,”MeasuredDistances”) lm(“Annotation Created.\n”,32) xsi.SetValue(str(oSet)+”.text”, “Distance Measurement Log\r”+”\r ————————————-\n\r” + nDist, “”) return #———————– #Log Distance def LogDist(): try: if SelectionCheck(): fromObj, toObj = xsi.Selection(0), xsi.Selection(1) newDist = “\r\nDistance between <“+fromObj.FullName+”> to <“+toObj.FullName+”> is: ” +str( ctr_dist(fromObj, toObj)) lm(newDist+”\n\n————————\n”,32) annotate(newDist) except: lm (“\n——-\nDistance Script Error.”,4) return True #—————————————- #Call the function – LogDist()

There you go… I hope it proves helpful to some of you. :)

I considered sharing my personal workgroup in it’s entirety, but there’s a lot of trash in there I wouldn’t want to burden people with, plus a considerable amount of stuff which Isn’t mine to share. So until I make a “clean” workgroup I’ll just have to post bits and pieces…

Example – Shapes in ICE and the Debugging Nodes

3D Graphics, Examples / By

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): exampleICEprotractor

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

Example – PostSim Needles

3D Graphics, Examples / By

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

[vimeo]http://www.vimeo.com/56985570[/vimeo]

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

 

Example – Propagate Attribute Thru Geo

3D Graphics, Examples / By

 

 

I made this a looong time ago and just now came across it, added some comments. It’s pretty classic ICE, a couple of attributes sweep through the vertices of a mesh and are used to drive particle values. I have no recollection when or why I made it, was probably just futzing around, but the basic task is one which comes up fairly often. For instance, on a recent commercial I did something akin to this to create a polygonized mesh “filling” effect. Similarly, on a film a ways back I used an approach like this to select points which were allowed to simulate, causing that classic “solid object burns into dust in an instant” effect. Handy for vaporizing vampires (however, oddly enough I didn’t get to use this trick on another horror film which actually had vampires. Go figure.)

 

File: softimage 2013 .scn 1.63 mb

example_propagateValueThruGeo

Example – Greeble Push in ICE

3D Graphics, Examples / By

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:

[vimeo]http://www.vimeo.com/56877450[/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

Post-simulation and Softimage ICE – extras

3D Graphics, Examples / By

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)

3D Graphics, Examples, Uncategorized / By

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)

3D Graphics, Examples / By

 

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:

x= a + r 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)

3D Graphics, Examples / By

“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!