Carsten Kolve's Blogschmog

Australia, Siggraph One Sheet

2009-11-21T00:36:00.000+11:00

Here the one sheet for the presentation Dan Bethell and I held at Siggraph 2009 in New Orleans: "Venomous Cattle For Australia".

Australia, Baz Luhrmann, 2008

2009-03-07T10:59:00.022+11:00

Lots to learn on the Australian outback epic. Doing a texture and animation reference shoot together with the guys from Animal Logic and a herd of very live and not always cooperative cows. Then some on-set survey and data aquisition work and experiencing first hand why it often makes sense to do stuff during shooting that you know won´t make post production easier.
And, of course, post production itself: My first gig as CG Supervisor included overseeing the development of RSP's inhouse crowd system "posse". It turned out nicely and will be a pretty flexible platform for all kinds of related and different work - hope to present some of the cool stuff you can do with it in the future. The majority of the cattle extension shots were done with it (not the stampede, though - that's Framestore). Shot bidding, coordinating work with 3rd party vendors, overseeing 2.5d set extension work in Nuke, deciding on technical approaches etc. and all the time keeping an eye on disk space and render farm usage. - Fun!

More info here: VFX World
Cattle extension and environment shot breakdowns: RSP

The Spirit, Frank Miller, 2008

2009-03-02T10:58:00.005+11:00

My second job as CG Supervisor (running in parallel with work on Australia) involved, apart from the usual general production pipeline work, making sure we could deliver a bunch of full cg city shots as well as a whole set of digital set extensions.

Unusual for a VFX production was the amount of creative freedom - allowing us to develop stylized looks for the scenes. One sequence involved splashing lots of cg blood around in a Japanese tea room - while not shown in this form in cinemas, it might make it onto an unrated DVD.

Lot's of info here: CG Society, VFX World
Shot Breakdown: RSP

The Ruins, Siggraph One Sheet

2008-11-03T10:59:00.000+11:00

For everyone who would like to have a peek at the one-sheet for my Siggraph 2008 talk during the "Rigging outside the Box" session, here is the link to the pdf "Large Scale Foliage Animation for The Ruins". There is more material available for everyone with an ACM account.

It details the same system I presented at the Digital Media Festival 2008 in Sydney.

The Ruins, Carter Smith, 2008

2008-04-18T04:24:00.000+10:00

Carnivorous vines with an appetite for fit teenagers are the main cg character in Dreamworks' horror movie 'The Ruins'. I worked as an R&D TD creating solutions for the animation pipeline. These included a new maya shape implementing Kochanek-Bartels splines used for controlling the vines and implementing parts of the layer based animation system for leaves (allowing you to combine different kinds of procedural animation with hand animation).

A system I designed to integrate Maya nCloth into the skeletal animation workflow allowed artists to resolve leaf on leaf and leaf on ground collisions. Other tasks included procedural rig building as well as integrating the animation layer system with a separate solution for massive amounts of background leaves.

There is an in-depth articles here: VFX World

Special Effects: The History and Technique

2008-03-24T05:02:00.000+11:00

You can now find a small interview with me on crowd simulation in the second edition of Richard Rickitt's excellent book Special Effects: The History and Technique

10.000 BC, Roland Emmerich, 2008

2008-03-23T04:10:00.004+11:00

When MPC started pitching for work on 10.000 BC, I was asked to start the development of a long-hair and fur pipeline named "Furtility". I worked on the software design of the system, developed a prototype and implemented hair dynamics solutions using the testcase of a charging mammoth.

As I moved to Australia I didn't stay on after pre-production, but the R&D guys and TDs at MPC did an amazing job completing the work!

There are nice articles about the production: FX Guide, CG Society and VFX World

Harry Potter and the Order of the Phoenix, David Yates, 2007

2008-03-23T04:08:00.005+11:00

For Harry Potter and the Order of the Phoenix (Warner Bros) Rising Sun Pictures created the outside of Nr 12 Grimmauld Place, various set extensions, a cg owl and magic sparklers. I initially worked on the transforming facade for Grimmauld Place and developed different ways to procedurally animate bricks and reveal features of the house like windows and balconies. However the overall fx design changed during production and I focused instead on the creation of a magic sparkling toy.

For the first time I used Houdini in shot production. The base of the sparkler was formed by a custom otl for instancing tube primitives controlled in shape and motion by various levels of noise and randomness as well as the velocity of the ball. The resulting sparkles were combined with each other to achieve the characteristic bifurcations. Sparkles were also instanced onto particles for the dynamic behaviour. The look of the sparkler was established in Shake using a variety of passes rendered in Mantra - the most useful of these were id, age, velocity and uv.

More about the HP5 production here: CG Cociety, FX Guide

Update! SideFx software has chosen to feature the shots in their 2008 Houdini reel.

Melfunctions

2007-03-26T05:24:00.000+10:00

About
mal.. mael... -wait- melfunctions is a plugin for Alias Maya that gives you access to many new mel command functions most of which are only very hard to replicate purely in MEL. A lot of the commands are actually convenient wrapper around functionality that is already in the Maya API and melfunctions gives the script writer access to this hidden power formerly only available to C++ developers.

Hopefully it will make it easier and faster to create more advanced solutions using Maya’s embedded scripting language.

Features

common matrix, vector and double math functions (all available on an array basis, too)
animation curve and shader sampling
mesh and instancer queries
plus lots more

Documentation

I tried to document the commands properly but have assumed basic scripting and cg related mathematics knowledge - don't be surprised if the documentation is a little short on examples and explanations!

Please read the documentation

Download

check out the most recent version of the source code from google code
there is also a compile (but most likely older) version available on highend 3d

The Last Mimzy, Robert Shaye, 2007

2007-02-10T04:07:00.001+11:00

A fun little project to work on! No massive pre-production and R&D phase here, just go in and do some cool shots. RSP was asked to create cg spiders in virtual nets - which I had the pleasure to model, animate and shade.

A spider net would be modelled as a poly mesh, and a little script would convert the edges of the mesh into dynamic Maya hair curves. End points of the hair curves were constrained to the original mesh vertices. This setup allows you to add some fake wind deformation via a noise based deformer to the mesh and then curves would deform dynamicly in a secondary pass. Curves were rendered in 3delight using an improved Charlotte's Web shader.

More information is available here: VFX Pro

Superman Returns, Bryan Singer, 2006

2006-10-23T03:59:00.002+10:00

My first job for Rising Sun Pictures in Australia. Not only was I able to flee the English weather, but also got the chance to work as an FX TD on the sequence where Superman returns in a meteor to earth.

The job was to come up with a nice looking meteor that would crash into the earth near the Kent farm. As the timeframe was quite small there was no time for custom development - instead we used Maya fluid shaded particles for the volumetric look (inspired by Peter Shipkov's cool Overburn setups).

Add a few utility passes generated in 3delight used for look tweaking and relighting - and the compositor made it all look great!

Read more about Superman Returns: FX Guide, VFX Word 1, VFX World 2

Poseidon, Wolfgang Petersen, 2006

2006-04-04T03:50:00.000+10:00

Warner Bros asked MPC to produce a full cg trailer for the remake of "The Poseidon Adventure" - showing the capsize of the Poseidon in a continous 1.5 minute underwater shot.

I worked as the Lead R&D TD on this project and developed various Maya particle setup and management systems for air bubbles. Lot's and lot's of bubbles. Bubbles in the ships wake, bubbles in splashes, bubbles bursting out of exploding compartment windows, a demolished funnel, exhaust pipes, open doors, debris, drowning people... all interacting with the motion of the fluid.

Unfortunately the full trailer was never shown in complete - however many parts of this massive shot were used in the promotional trailers.

Read the VFXPro article on Poseidon here.

Kingdom of Heaven, Ridley Scott, 2005

2005-12-20T03:42:00.000+11:00

More crowds! For Ridley Scott's crusader epic MPC's crowd team perfected the "large crowd" simulation workflow. The most important addition to the toolset being a system to reuse simulations as building blocks for other simulations, making the generation of very complex and coordinated crowd motion fast and easily controllable. Besides working in R&D on the enhancement and restructuring of the inhouse crowd system I was again a Simulation TD, creating the crowds seen in the Siege sequences and the vultures of the Battle of Hattin aftermath shots.

The vultures were controlled by a procedural bird flight emulation system which automaticly adjusted the flapping and banking behaviour based on it's speed, distance to ground and air pressure differences (a simple 3d perlin noise map). It was again realised as an ALICE network. I used guide curves to direct individual hero birds.

I added multiple digital stunt double falling and jumping out of collapsing siege towers, crashing into the ground or onto other soldiers - they were realise using PAPI. This is a proprietary physics tool in Maya which allows the seamless blending of motion capture data and ragdoll dynamics.

After more than 2.5 years of development ALICE has reached a very mature state - it is possible to add "inteligence" to virtual every Maya object - from individual characters driven by procedurally controlled motion capture data to vertices in a cloth mesh analyzing their surrounding.

It was a nice surprise that the team's work on Kingdom of Heaven was honored with a VES award for Best Supporting Visual Effects in a motion picture - see the "making of" here.

If you haven't seen it yet, be sure to check out the Director's Cut - it's vastly superior to the theatrical release!

Batman Begins, Christopher Nolan, 2005

2005-06-13T03:36:00.000+10:00

Batman Begins was the chance for me to add another dimension to crowd simulation - the third one. ALICE had so far only been used to produce simulation running in 2d, but for the swarms of bats this was clearly not sufficient. After creating a suitable simulation bat rig in conjunction with the Rigging TD I extended the crowd system to support full 3d movement of agents. In addition I build a Maya dependecy graph rule network which would emulate the flight behaviour of bats.

Custom tools to control the flight motion (eg. guide curves, flow fields and obstacle detectors) helped the Shot TD's to direct the bats, artificial live techniques (like the well known flocking behaviour) added additional variation.

Numerous companies worked on Batman Begins, more about the production here.

Alexander, Oliver Stone, 2004

2004-10-23T02:41:00.000+10:00

Most of the crowd effects in Alexander were done by the french company Buf. However a number of more close-up crowd shots depicting the battle in the Indian jungle were executed by MPC's team - simulating horses for the first time using ALICE. Apart from a view simple tasks I was not directly involved in the production - however I created various example shots demonstrating the crowd system we developed. They were used to convince the director we were able to produce the battle scenarios he was asking for.

All about the effects in Alexander here.

Troy, Wolfgang Petersen, 2004

2004-07-23T02:20:00.000+10:00

Troy was my first vfx feature - The Moving Picture Company hired me based on my previous work on crowd simulation (some of which you can see on the site) to become one of the core R&D developers of ALICE. ALICE is the acronym for Artificial LIfe Crowd Engine and a Maya based multi agent animation system that enables Crowd TD's to create crowd layouts and simulations using Maya's build-in and a whole lot of custom tools.

Crowd control networks can easily be generated by simply plugging dependency nodes together. I developed various parts of the ALICE: nodes to control crowd dynamics (math, (fuzzy) logic, state machines, flow control, etc.), the integration of crowds with particle systems (for arrow impacts, dust kicks, blood splashes, etc.), data visualizer and a new interface which enables TD's to build, manage and debug crowd control graphs easily.

After an extensive R&D phase we finally went into shot production. As a Crowd TD I completed the majority of battle shots. Most of the fighting between the two armies is done using artificial life techniques (or just a good layout and extensive use of randomness and noise).

For the close combat scenes I devised a system which enables the use of pre-choreographed multi-character animation clips within a crowd simulation. It was used to insert many high quality 1-on-1 fights performed my stunt actors into the melee - which helped a lot in making the action more believable.

More information on the production of Troy can be found here.

Spider Crawling System

2004-06-25T06:13:00.000+10:00

About

This tutorial describes how the mel based spider crawling system used in the brainbugz video works. It's not a proper tutorial yet and there are many parts of the used scripts could be made better, but until I find the time for it this will have to do :-)

To begin, download this file, open and play it. The spider should walk along the motion path as time progresses, adapting to the terrain. Change the motion path or the terrain to see that the motion is entirely procedural.

The Spider Setup
The spider is the example is a pretty simple proxy model - but could be replace with a more realistic one:

The top of the hierarchy is it the locator spiderController1. Under it you'll find the spider's body spider1. 8 legs are parented under the body. Each of them consists of a number of joints that form the leg, these are controlled by an ikControl with an ikHandle at the end. With it's motion the complete leg can be controlled. The individual geometry segments are just parented under these leg joints.

Procedural Animation
So, how does this beast move?

The body:
spiderController1 is animated along the motion path. The body spider1 is contrained to the terrain with the geometryConstraint spiderGC. In addition to this the normalConstraint spiderNC is sampled within an expression that controls the alignment of the spider's body. Within the expression spiderBodyExpression (which drives the body transform) you can see how this is done - noise is added to added to the body's rotation to make the motion more natural.

The legs:
Now this is where it get interesting: If you look at the Attribute Editor > Extra Attributes section of the spiderController locator, you'll see a number of parameter - they all control how the spider leg moves. The spider animation is cyclic, the length of the walk cycle is not determined by time, but by transition along the motion path. walkCycleTransition determins the length along the motion path which is used for one cycle. All the animation controls work relative to this range. For convinience this transition length is treated as 1, so the range is normalized (between 0 and 1) and all animation controls related to timing operate in this 0-1 range. In particular these are stepStart and stepDuration, they determine when during the walk cycle a single step starts and how long it will take. So when moving along the motionPath for every leg it is determined if

the time is not ready to step - in this case keep the ikHandle which controls the leg planted at it's current position
the time has arrived to start a step - store the current position in currStepStartPos and set currStep to 1 (this indicates a step is taken), determine an end position for the step (this is done by adding the end position relative to the body relStepEndPos to the body's position, this position is then transferred to the surfacePointLocator which is connected to a closestPointOnSurface node spiderSurfacePointFinder which in turn gives us the final end position for the current step on the surface currStepEndPos - phew!)
the step is currently taken (currStep is 1) - if we are stepping a simple hermite interpolation is used to compute the position of the ikHandle at the end of leg, from currStepStartPos to currStepEndPos starting with a tangent of stepStartTangent and ending with stepEndTangent. the step's progress is determined by the current progress through the cycle transition length, stepStart and stepDuration (for more insights check the "hermite" mel command)

To see how this is all achieved in practice, check the expression which drives the extra attributes of the spider controller.
I hope this was not too technical and gave you some insights into how this procedural animation was achieved. If you have any questions or suggestions how to made it clearer, please contact me.
Of course there is a lot of space for improvements - feel free to experiment and I'd be interested in seeing what you come up with!

Brainbugz

2004-03-26T05:24:00.001+11:00

About
brainbugz is a set of A|W Maya nodes and commands that enable you to use behavioural animation techniques on particles. A particle system is a system in which forces such as gravity or wind are applied to mass-points, so that these mass-points change their position in space. In contrast to this, in behavioural animation mass-points are not forced from the outside, forces are self applied based on physical attributes and one or many behavioural rules. These so called steerings desires can be clever combined and attached to a number of mass-points, so these mass-points are no longer simple physical objects, but become autonomous characters, referred to here as „bugs“.

This concept tries to reflect real life on an abstract level, where all characters act based on individual behavioural rules, their view of the world and the other characters surrounding them. Think of a school of fish, a flock of birds, athlets running a marathon - all groups of individuals with local behavioural rules (avoid touching the other characters, get from point A to point B, try to stay near the other group members, ...), but the sum of all individual local movements results in a more or less coordinated crowd motion.

Features

13 different steering desires:
individal bug based: head direction, wander
target based: seek, moth-seek, arrival, pursuit, shadow, following of curve / surface, obstacle avoidance
neighbor based: alignment, cohesion, separation, keep distance
all desired can be used as stand alone force fields
desires can be combined with each other and / or standard fields to achieve complex higher level behaviours (e.g. flocking)
easy to use interface, no scripting needed to setup a behavioural system

Documentation
You can read the brainbugz documentation here.

Download

check out the source code from google code
download the compiled plugin for various platforms from highend 3d

Examples
A bunch of spiders, crawling on uneven terrain and avoiding obstacles. Behavioural particle motion was converted to paths. Spiders driven by an expression based walking system for legged motion were attached to these paths.

Flocking - Particles performing the infamous flocking behaviour.

Wacky Vehicle

2003-04-25T05:51:00.000+10:00

About

While you have learned in the rolling ellipse tutorial how to roll an ellipse on the floor, we will now use this expression to build a funny moving vehicle. I won't focus on modelling issues, but on the math to make this little thingy move.

Modeling
Let's build a simple proxy model of a vehicle. We'll start with the wheels:
Create a polygon cylinder (radius = 1.0; height = 0.3; subDivs around axis = 20; subdivs on caps = 0; axis = z;), rename it to "wheelFL" - this will be our front-left wheel. Delete its history.
Scale the wheel by 2.0 in x-direction. Create a locator "locFL", make it a child of the wheel. This will be the contact point with the main body later on.
Note: Of course you are free to use a nurbsCylinder, too.

Dublicate the wheel 3 times. Rename the new wheels to "wheelFR", "wheelBL", "wheelBR". Update the child locators accordingly, too.
Move "wheelFL" to [3,1,-3], "wheelFR" to [3,1,3], "wheelBL" to [-3,1,-3], "wheelBR" to [-3,1,3].
Create a polyCube "body" (w=10; h=1;d=5). Create a locator "vehicle", move it above the vehicle parts and freeze its transforms.

Rigging

Now that we have build ourselfs a nice little vehicle, let's add some funcionality. - First, parent all vehicle parts to the "vehicle" locator. We will use this locator to move the vehicle later on.
Your outliner should look like this:

We will now turn the "vehicle" locator into the interface to the expressions, driving the animation of our vehicle. Add custom attributes as shown on the left to the "vehicle" node.
The ones ending with "_EXPR" are of type "integer" and their purpose is to give us easy access to the respective expression.
The other ones will serve us as a means to enter a rotational offset for each wheel. Ther are of type "float".

Now we'lll add slightly modified version of the roll ellipse script to each of the wheels.
Add the below expression to each of the respective wheel expression interface attributes, don't forget to change the name of the wheel accordingly (you can quickly do this by using a "search and replace" on "FL" in your favourite text editor). I won't go much into details here, take a look at the first tutorial for more information.

// helper connection to the interface attribute
vehicle.wheelFL_EXPR =0;

// constant values
$pi = 3.141592;

// radii of the elliptical wheel
$rA = 2.0;
$rB = 1.0;

// get translation of the vehicle and offset of the wheel
$x = vehicle.translateX;
$rotZOffset = vehicle.rotOffsetFL;

// as we are working in radians, convert the rot offset
$rotZOffset = deg_to_rad($rotZOffset);

// compute perimeter of elliptical wheel
$per = $pi*($rA+$rB);

// compute the rotation of the wheel
$rot = (-2*$pi*$x/$per)+$rotZOffset;

// adjust the y-position of the wheels center
$y = abs((-sin($rot)*tan($rot)*$rA*$rA)-(cos($rot)*$rB*$rB))/
    sqrt($rA*$rA*pow(tan($rot),2)+$rB*$rB);

// apply the results to our wheel
wheelFL.translateY = $y;
wheelFL.rotateZ = rad_to_deg($rot);

Test if all the wheels are rolling correctly by moving the vehicle locator in x-direction. Change the rotational offset values to test if they work correctly, too. Make sure everything runs fine.
OK? Good, on to the movement of the body. The pupose of our expression is to move the main body so it tries to stay in contact with the contact locators on the wheels. Our first concern is to adjust the position of the main body, we will move this to the mean position of all contact locators. Of course, we've got to use their world position for this as they are not on the same hirachy level as our "body"!

// helper connection to the interface attribute
vehicle.body_EXPR =0.0;

// get positions of contact points of every wheel
float $pos[];

$pos = `xform -q -ws -t locFL`;
vector $posFL = <<$pos[0],$pos[1],$pos[2]>>;

$pos = `xform -q -ws -t locFR`;
vector $posFR = <<$pos[0],$pos[1],$pos[2]>>;

$pos = `xform -q -ws -t locBL`;
vector $posBL = <<$pos[0],$pos[1],$pos[2]>>;

$pos = `xform -q -ws -t locBR`;
vector $posBR = <<$pos[0],$pos[1],$pos[2]>>;

// compute mean position
vector $meanPos = ($posFL + $posFR + $posBL + $posBR) / 4.0;

// [..]

Our next step is to get the rotation in x- and z-direction for our body. We'll measure the angles between the relative axis and the vector between the respective wheels, to obtain the angle by which we have got to rotate the vehicle's body.

// [..]

// get x-angle between the left and right contact position and
// the z-axis, do this for front and back, our rotation angle
// will be the mean angle

float $angleXF = `angle <<0.0,0.0,1.0>> ( $posFL - $posFR )`;
if ($posFL.y > $posFR.y) $angleXF = -$angleXF;

float $angleXB = `angle <<0.0,0.0,1.0>> ( $posBL - $posBR )`;
if ($posBL.y > $posBR.y) $angleXB = -$angleXB;

float $angleX = ($angleXB+$angleXF)/2.0;

// get z-angle between the front and back contact position and
// the x-axis, do this for left and right, our rotation angle
// will be the mean angle

float $angleZL = `angle <<1.0,0.0,0.0>> ( $posFL - $posBL )`;
if ($posFL.y < $posBL.y) $angleZL = -$angleZL;

float $angleZR = `angle <<1.0,0.0,0.0>> ( $posFR - $posBR )`;
if ($posFR.y < $posBR.y) $angleZR = -$angleZR;

float $angleZ = ($angleZL+$angleZR)/2.0;

// [..]

Finally, we have got to apply the results to the "body":

// [..]

// apply results to body, take into account that "body" is
// parented to "vehicle"

body.translateX = $meanPos.x - vehicle.translateX;
body.translateY = $meanPos.y - vehicle.translateY;
body.translateZ = $meanPos.z - vehicle.translateZ;

body.rotateX = rad_to_deg($angleX);
body.rotateZ = rad_to_deg($angleZ);

Here you are! - Some suggestions:

try different rotational offset settings
change the size of the wheels (don't forget to adjust the radii in the expressions!)
move the position of the contact locators on the wheels

Download the scene at highend3d.

Example Movie
to come

Rolling Ellipse

2003-03-25T01:47:00.000+11:00

This tutorial shows you how to roll an ellipse on the floor, using Maya expressions. Have no fear, I won't go too much into mathematical details here, but will provide you with ready to use expressions for copy and paste. If you really want to dive into the wonders of elliptical calculus, you'll find the links to sites I used to obtain the mathematical background information at the end of this tutorial. I'll assume you are familiar with basic Maya workflow (expression editing, geometry creation, etc.) and some basic math, your angular unit should be "degrees".

The Rolling Circle

Before we'll roll an ellipse, let's see how to roll a circle as we can apply the insights gained from this on the ellipse proplem.

Create a nurbsCircle (radius = 1.0; axis = z;), rename it to "circle", switch to othographic front view, move the center of the circle to [0,1].

Note: Instead of a nurbsCircle you can also create a nurbsCylinder, so you'll be able to watch the movement of the object in perspective view more clearly.

Now we'll add a little expression to the z rotation of the circle:

$pi = 3.141592;
// radius of circle
$rA = 1.0;

// get translation in x direction
$x = circle.translateX; // perimeter of circle
$per = 2.0 * $pi *$rA;

// rotation circle has made when travelling x units
$rot = -360.0 * ($x / $per); // apply rotation to circle
circle.rotateZ = $rot;

What have we just done? When you move a circle on the ground, the length of the arc has to equal the length travelled in x-direction. So the rotation required to do this can be obtained as a function of the complete rotation of a circle (360°), the length travelled in x-direction and the perimeter of the circle. A final multiplication with -1 will ensure the circle rotates in the correct direction. Alternativly you could use this expression, which is a condensed form of the upper one, faster to execute but not very readable

$rA = 1.0;
circle.rotateZ = -57.29578 * circle.translateX / $rA;

Move the circle in x direction and see how the expression rotates your circle correctly.

The Rolling Ellipse
Now on to the rolling ellipse: Scale the circle by 2.0 in x-direction, rename it to "ellipse".

We will start like we did with the circle and find an expression for the perimeter of the ellipse. Unfortunatly there is no simple formula for the circumference of an ellipse like the one we used for the circle (2*PI*r). In fact, obtaining the exact result is not an opportunity here as it would require us to deal with sums of infinitely many terms, elliptic integrals and the likes... everything not only very complicated and difficult to implement but also very computational expensive. Luckily there exist quite a lot of much simpler approximations for the perimeter of an ellipse, so we just use these. It's in the nature of approximation that it inherits a relative error, but we will choose formulas that will have a very small error so the effect won't be very visible.
I will give you some approximation formulas, sorted by relative error (from big to small), choose one wich you works best for you (in many cases already the simplest one will give good results).

$pi = 3.141592;

$rA = 2.0;
$rB = 1.0;

// compute perimeter
//

// simple
$per = $pi*($rA+$rB);

// Kepler
$per = 2.0*$pi*sqrt($rA*$rB);

// Euler
$per = $pi*sqrt(2.0*($rA*$rA+$rB*$rB));

// unknown
$per = $pi*sqrt(2.0*($rA*$rA+$rB*$rB)-(pow(($rA-$rB),2)*0.5));

// Ramanujan I
$per = $pi*(3*($rA+$rB)-sqrt((3*$rA+$rB)*($rA+3*$rB)));

// Ramanujan II
$h = pow(($rA-$rB),2)/(pow(($rA+$rB),2));
$per = $pi*($rA+$rB)*(1+3*$h/(10+sqrt(4-3*$h)));

Now that we have got the perimeter, let's compute the angle of rotation required to fit the translation of the ellipse, just like we did with the circle (note that we are working in radians here, hence the 2*PI instead of 360°):

$x = ellipse.translateX;
$rot = -2*$pi*$x/$per;
ellipse.rotateZ = rad_to_deg($rot);

IMPORTANT: This is mathematically wrong! I made the assumption that the ellipse had everywhere the same curvature (like a circle), but this is not true. So this will only look correct if you do not have very elongated ellipses. I will update this tutorial when I have found a simple solution to this problem (the arc length and angle relationship is not linear!).

Now that we have found the rotation, we still need to adjust the y-position of the ellipse's center.

$y = abs((-sin($rot)*tan($rot)*$rA*$rA)-(cos($rot)*$rB*$rB))/
sqrt($rA*$rA*pow(tan($rot),2)+$rB*$rB);

ellipse.translateY = $y;

Yes, that looks scary. I won't go into much detail about this term, but basically it epresses the y-component of the point of tangency for a specific angle, rotational transformed to fit the current coordinate system for the ellipse. Add the expression to your scene, move the ellipse in x-direction and watch it rolling on the floor.

Enjoy :)

You can download an example scene at highend3d.

I used these pages for reference: Mathworld, Numericana, Maple Center

Simulating Crowd-Motion using Behavioural Animation

2002-03-25T04:24:00.000+11:00

About

"Simulating Crowd-Motion using Behavioural Animation" is title of my diploma for the grade of Diplom Informatiker (FH) at the University of Applied Sciences Dortmund which I successfully completed in May 2000. You'll find the paper on the topic , the implementation of the findings and some sample animations generated with my software. This work is heavily based on the findings of Craig W. Reynolds, the man who released papers on behavioural animation first and inspired people to use such techniques in films like "The Lion King" (Disney) or "Jurassic Park" (Universal) to animate crowds. Visit his website, it is an excellent starting point for many highly interisting topics of computer graphics and artificial intelligence.

Diploma
Creating computer animated crowd scences for use in film, television and other media is an area, where traditional techniques used in computer animation can only be used with great difficulties. This paper deals with one possible approach for creating these kinds of scenes at relativly low expense: Behavioural Animation. A implementation model is presented, based on so called autonomous agents, their physical properties and steering behaviours. It is examplary implemented in the simulation software bugz, including an interface to the animation packages Maya 2.5, Lightwave 6.0 and Cinema 4D XL.

Diploma "Simulation von Gruppenbewegungen durch Verhaltensgesteuerte Animation"

(Adobe Acrobat PDF, 547 KB, German version available only)

UML Class-Modell

Bugz

bugz is a standalone behavioural animation system. With bugz you can create autonomous characters, change their physical attributes and apply various predefined steering-behaviours (you can even change them over time by using so called "triggers"). Finally you are able to create nice looking crowd motions by simulating their interaction in a 2d-world. Besides pure viewing pleasure, the motion data can be used in a computer animation package (plugins are provided).
In case you are interested in source code, you'll find the code for the most important functions at the end of my paper.

bugz 1.0 win (ZIP 380 KB)
incl. example simulations and import scripts for Maya, Lightwave, Cinema4D XL
bugz User Manual (Adobe Acrobat PDF, 191 KB, English)

Sample Animations

All sample animations were created using bugz, Lightwave 6.0 and Cinema 4D XL 5.0.

Seek-behaviour causes the bugs to align their orientation towards the specified target. If a bug continues to seek, it will pass through the target, then turn back to seek it again.
ObstacleAvoidance: Circle - Bugs try not to crash in the circle by checking if they'd hit in in the future and if so, steer away from the circle
Cohesion - Bugs with this behaviour will try to approach and form a group with other nearby bugs by heading for the average position of these bugs.
ObstacleAvoidance: Group - A example of a combination of various steering beaviours: Seek makes the bugs move in one direction, separation prevents them from crowding together, cohesion keeps the group together, obstacle avoidance helps them not to crash in the box.

Bonus: Fireflies, Flies, Fish - All the bonus animations are examples of autonomous agents seeking (moving) targets using the MothSeek behaviour, which causes a bug to move around a target in elliptical paths, much like a moth seeking a light bulb.