Curly Maze

A maze like pattern made by copy stamping 3 different shapes onto a grid.

Grassy Grass

A grass simulation using fur. The movement is driven by animating the point normals on the surface using a Perlin noise offset. The color is changed by attribute transfer of point color from a single point in the center. No dynamics were used, only SOPs.

The style of the grass was inspired by a Playstation 3 game called Flower.

Umbrella Crowd

An animated walk cycle thats copy stamped on a simple particle system. Just having some fun.

SPH Geometry Melt

I used SPH fluid particles to drive the shape of the geometry to get a melting effect. The particle fluids have a high viscosity and surface tension.

High Viscosity and Surface Tension

The SPH particles are imported to SOPs and brought into a lattice that deforms the geometry. The rest input needs to be from the first frame.

Lattice SOP

Paper Pixels

A combination of the Runaway Post-it Notes and the 3D Game Sprites projects.

I used two different but similar game sprites, Mario and Luigi from the original Mario Bros. game. They only differ in color palette. The color attribute is blended down the Y-axis to get a nice gradient as the paper blows away.

With so many stacks of particles, I needed each of the stacks' particles to be grouped from top to bottom at a random rate. The first step was to set an attribute that specifies the "stack number" in SOPs. I set the Alpha ($CA) point attribute equal to the point number ($PT) of the template. That stack number ($CA) is kept after the Copy SOP so that the particles can use it.

Next, in the particle network, I created a random step curve in CHOPs which goes up by increments of 1 at a random rate. I created as many curves as I needed. The names of these curves will correspond to the stack number of the particle.

Finally, by using an expression, I got the particles to group from top to bottom. The modulo operator is very useful. Particles within this group will be effected by the wind and other forces.

3D Game Sprites

I got this idea after playing a game called 3D Dot Game Heroes.

This is very easy to do in Houdini. I just found some sprite sheets from old 8-bit video games on the web. Then I just UV mapped them on a grid of points and copied boxes on them inheriting their point colors.

Basic Procedure

Sprite Sheet

Pick out a specific sprite

After I cropped out my chosen sprite, I needed to save the image as a TIFF or PNG to keep the Alpha channel. It comes useful later.

Houdini Network

VOPSOP Network

The image is UV mapped on to a grid of points. Then Color and Alpha point attributes are fetched from the image. If the value of Alpha is zero, the point is deleted, creating a cookie cut-out of points.

Boxes copied to remaining points

Dealing with Sizes

Grid SOP

The game sprites can vary in pixel size, width and height. To ensure that the grid will have the correct number of rows and columns, I brought the image into COPs and was able to fetch its size data using an expression.

16-Bit Sprite

Arcade Size

Guilty Gear vs Street Fighter

As technology advanced, game sprites became larger and could create more detail. Also a wider range of color values could be used. This might explain why earlier game character designs were more simple and used fewer colors. Like MegaMan, who still to this day retains the simple design he had way back. I think its interesting to see how the designers were able to do this stuff with such limited resources and still create something pretty entertaining.

Pinball Machine

Another combination of DOPs and CHOPs.

By using the Impact data that's created in a dynamics network when two objects collide, I created a graph in CHOPs that drives the size and color of the bumpers.

In the details view in DOPs, when two objects are colliding with each other, an Impact record will appear on each object involved. It will only appear on the frame where they touch, and will disappear until they interact again.

If you look at one object's Impact record, you can see object ID of the other object involved, the simulation time at which it took place, etc. The main piece of data I used in CHOPs from the record was the flags data, which is just "flagging" that the data exists and is set to a value of zero.

After bringing the raw Impact flags to CHOPs using a Dynamics CHOP, I needed to make some math adjustments and then record the graph.

Then I added a Spring CHOP to it and exported it to the bumpers' scale, ....

and in another branch use a Lag CHOP and bring it to the bumpers' color.


RBD vs ODE
I later converted all of the objects in the simulation into ODE objects for more accurate results. I then realized that when using the ODE solver, you cannot create Impact data. So later I only used the ODE solver for the pinballs and used the original RBD solver for the bumpers. So now the bumpers were able to receive Impacts.

Houdini Tetris

SOP Level

I started with a 4x2 grid, and deleting primitives to create the tetrominos in the game. Each tetromino consists of 4 primitives.

All of these geometries went to a Switch SOP. The input parameter has an expression that randomizes the input by time. The flat shapes are later extruded. This will be the source of the RBD objects in the DOP level.

DOP Level

RBD Object DOP

When bringing them into DOPs, a tetris piece needs to be "emitted" not only on the first frame, but also when the piece before it hits the ground. This is done by the expression in the Creation Frame parameter:

if($FF==1 || dophasfield("..",$OS+$SNOBJ-1,Impacts,Impacts,0,flags)==1,$F,0)

In DOPs, when an RBD object makes contact with a collision surface, there will exist Impact data called "flags". So once the current object, $SNOBJ-1, receives this flag, a new piece will be created.

Group DOP

I created two groups, one called "falling" which is the current piece, and "hit" which are the pieces at rest. The groups are detected by the Y velocity.

RBD State DOP

An RBD State DOP was used to force the velocity data to zero of the "hit" group. This will keep the pieces from bouncing and moving dynamically.

Motion DOP

In a Motion DOP, position was overridden using CHOPs. I could control the position of the falling piece using the keyboard or a game controller via CHOPs while the simulation was running.

CHOP Network

The CHOP Network records a graph while DOPs is running and can directly move the pieces in realtime. The result of the network above plugs directly into the Z position of the Motion DOP.

Resulting curve for side to side motion.

DOP Network

Afterthoughts

This was an experimental project and I learned alot about DOPs and CHOPs. I may later come back to this one to try and figure out how I can rotate the pieces without any bugs and of course enable the blocks to disappear after creating a line.

VEX Toon Cross-Hatch

This VEX Material simulates a toon, cross-hatching effect where based on the lighting and shadowing of the object will produce a wire-frame like pattern, similar to a drawing or comic book.

It is based on the luminance that the object gets from the lights in the scene. After the Lighting VOP, I used a Luminance VOP to get monochrome values, which range from 0 to 1. Then these values are color ramped. This yeilds a basic toon effect.

Using Constant Type ramping. You can add as many colors to the ramp as possible.

Now, instead of using the Color Ramp to directly change the surface color, I used a Scalar Ramp to change the width of the lines produced by a Wireframe VOP. So what you have is when the light brightens the surface, the lines will get thinner, and in the shaded area and the shadows, the lines will be thicker.

Since I gave the Wireframe VOP UV coordinates, it is best to add UVs to the geometries in SOPs.

I also got different results using Micropolygon or Raytraced rendering. Since using raytraced shadows and raytraced rendering is more presice, they yeild more order to the lines. Both ways look nice in their own way.

Micropolygon Rendering

Raytraced Rendering

VEX Network.

MEL Phoneme System

This MEL script allows the user to enter pronounciations and automatically keyframe each mouth movement to a speech sound, or phoneme, to the mouth of a rigged character in Maya. The animation rig that is being used was developed by Jason Osipa, author of Stop Staring: Facial Modeling and Animation Done Right.

The "Stop Staring" Rig

2D Vector Sliders. Model by Anthony Brown.

The "Stop Staring" Rig is made up of 2D Vector Sliders in the HUD. The sliders correspond to different parts of the face. The values in the sliders are set up like a coordinate system of 2 to 4 quadrants that go from -1 to 1 or 0 to 1 in X and Y space. I'm no animator, so I'm not sure how its attached to the character. My only job was to create a script using this rig that would make it easy for the animator to make the character's mouth move accurately with speech.


The Phoneme Script

When my script is loaded, it brings up a window where the user can type in a series of speech sounds, or phonemes, in the text field. Each phoneme must be seperated by a space. If you want the character to hold a mouth movement for a little while longer, add a space then a hyphen ' - ' after the phoneme. If you want the character to close its mouth after the series is done, add a space, then a period ' . ' . When you are done, set the time increment that you want each mouth movement to set a keyframe. (Default is 5). Once you are done, click "Process Words". The script will automatically set key frames for the Sync, Lips, and Tounge sliders of the rig for each phomene by the given increment.


Example Phoneme Series'

Here are some example phoneme series' to show how to operate the script. After these are keyframed. the animator can tweak the animation to match thier style. If you type in letters that don't match any phoneme included in the script, they will be skipped and give undesired results.

"Hello World" = e l o w - l d .
"Thank You" = th a n k u .
"What the heck are you doing?" = w a th a e k a u - e n .
"This.. is.. Sparta!" = th i s . - i s . - s p a t a .
"Royale with cheese" = r o a l w i th ch e z .

The character saying, "This.. is.. Sparta!"

and "Royale with cheese."

References

I referred to the phoneme lip sync charts in Facial Expressions: A Visual Reference for Artists by Mark Simon, a great book for 2D and 3D character animators.

Phoneme Charts