digibutter.nerr

[Admiral Bobbery]

Would you like to see how Mario Galaxy created its unique gravity-based physics effects for the in-game planets? Developer Jeremy Alessi of Gamasutra analyzes and reproduces the same concepts with a playable game prototype and source code.

Here's his article that he wrote earlier today:

"Welcome to the first article in a new Gamasutra series called Games Demystified. In this series I'll be deconstructing games with unique or distinguishing mechanics that may have left some folks scratching their heads, including reproducing effects with code samples, examining -- just how did they accomplish that? The first game we'll be covering is Super Mario Galaxy for the Nintendo Wii.

Upon release, Super Mario Galaxy enchanted the gaming community because it allowed gamers to walk upside down and inside out -- all while feeling completely intuitive. Especially geeky message boards and blogs have lit up with people attempting to apply real-world physics equations for gravity to each of the game's tiny planetoids.

Obviously, real world physics have a place in today's games. However, they take a backseat to psychology when it comes to making real world gameplay. In reality, mass distorts the fabric of time and space causing gravity, the force that keeps us stuck to Earth.

People such as Isaac Newton have studied and derived a great deal about gravity, but no one actually knows the true mechanics behind the force. The important thing for the game is that we expect to get pulled toward planets -- and in fact, Mario does get pulled to each and every strangely shaped planetoid in the game.

Normally, gravity is calculated as a force between two objects that is directly proportional to the product of their respective masses and inversely proportional to the square of the distance from the objects' centers.

Force of Gravity = Gravitational Constant * ( ( mass1 * mass2 ) / distance2)

To simplify, gravity follows the inverse square law.

Intensity of Gravity = 1 / Distance2

This means that as an object moves closer to a planet, the gravity between them increases exponentially. Conversely, as an object moves away from a planet the gravity between them weakens very quickly.



Traditionally, the force of gravity is applied using the radius of the more massive body. For instance, if we were to calculate the gravity holding a person to Earth we'd plug the Earth's radius into the above equation. Additionally, if the mass is great enough to hold a person down, the celestial body will be round. This is where reality and Super Mario Galaxy differ.

In Galaxy, players are pulled toward each and every arbitrarily shaped planetoid they encounter. At this point all real world physics equations break down and tell us nothing about the gravity in the game, which as in most cases is a trick. Much like the magicians in The Prestige, game developers are always attempting to one up each other with new tricks. As we all know, Nintendo stole the show with its latest.

To accomplish this "trick", the developers use the surface normals of whatever planetoid Mario inhabits to keep him running and jumping happily along. This is how gravity is distributed through completely irregular bodies. A surface normal is a ray or unit vector that runs perpendicular to a plane.

In the illustration above we can see an arrow pointing up from a plane, the arrow represents the surface normal of a plane that points straight up. If we're using a Y-up right handed coordinate system, that normal would be a (0, 1, 0) which means it's not pointing along the x or z axes at all and that the full length of the vector is all in the up direction.

A unit vector always has a length of 1, which is then distributed amongst the x, y, and z directions. The longer one direction is the shorter the others must become.

As stated above the shapes in the game are often strange and in real life the effects of gravity would probably cause Mario to fall all over himself. In the game however, he always comes out a hero by landing on his feet and in general looking really slick as he traverses the strange surfaces, such as the one below.



Calculating real gravity on a surface like this would be a task best left to Stephen Hawking. However, for the game to play correctly, the developers merely had to cast a ray relatively down from Mario's local center and grab the nearest surface normal.

Inside any 3D game engine worth its salt, there is a list of all polygons being rendered on screen and we can retrieve the first polygon that our ray cast intersects.

That polygon in this case represents our plane and the inverse of its surface normal represents the direction of gravity that will pull Mario smoothly back to the planetoids surface. That polygon's surface normal is also used to align Mario to the curvature of the planetoid.



In the illustration above we can see that the character is aligned to the surface normal of the previously jumped on polygon but the ray cast (dotted line) now intersects another polygon as the player crosses the border from one polygon to the next. In Galaxy, Mario's orientation is adjusted extremely smoothly due to a combination of factors.

First and easiest to understand is that each planetoid in the game is fairly high polygon so the change from one surface normal to another isn't too steep. Additionally, interpolation can be used to smoothly transition from one orientation to the next. So, the surface normals in a Galaxy planetoid are analogous to the key frames of an animation in that regard.

To demonstrate these concepts we'll be looking at some high-level source code we've created - written in Blitz3D, which is an excellent tool for prototyping concepts just like this. You'll need to download a demo or full version of Blitz3D to edit and re-compile the code.

Here's the specially created executable/source code package for readers to try that demonstrates a lot of the concepts used in Galaxy. The source code does a number of things including setup, camera tethering, and rendering.

The component we'll be focusing on is the updatePhysics() function - here's a code sample from that section:

[Dino Piranha]

AHHH! TOO MUCH INFORMATION!

[Paper Luigi]

Tl;dr

[Tiptron MKII]

Holy Crag! I think my brain imploded. Some one needs to reboot me.

[Launching Star]

*reboots Tiptron*
O_o And I thought my brain was hurting already from learning so much of the Japanese language recently... *brain borks*
*Five minutes later, after a brain unborking via Return to the Past...*
The only parts I recognized was the code snippet. It resembles Lua syntax, but is WAY too complexicated to be executable in Roblox Lua. For one, entityCollided would have to be changed to script.Parent.Touched, and the RBX Lua Compiler would look for Vector3.new() instead of AlignToVector()... Wait what am I saying?! *brain asplodes again*

[Super Gwag Meister]

Awesome...

[Merlink]

This is interesting. I was always wondering how SMG managed to simulate gravity so realistically, yet so far from reality.

[Kamek]

*Head explodes* Complicated!

[Zelnor]

Fascinating.


What ? I'm a nerd, don't look at me like that. I don't get the code either and skipped a part, but it isn't that hard.

[Tails Doll]

Hmm, complex. Snazzy.

[MALAK]

Wow.

[Anti-Guy]

interesting, simle enough.... once you get past the fancy words. its just a core idea of gravity.

[Manjew]

I didn't get 3/4 of what they said, but I did understand a part of it.