Question

What is the best mechanism for handling large scale structures and scenes?

Examples being a continent with scale cities and geography, or infinity universe style planetary transitions.

Answer 1

The biggest problem with working with floating point representations of positions in large scale is that you rapidly lose precision as you get further and further away from the origin.

To remedy this you need to express all positions as relative to something else than the origin. The easiest way to do this is to partition the world into a grid and store the positions of all entities something like this:

struct Position {
    int kilometers[3]; // x, y and z offset in kilometers
    float offset[3]; //x, y and z offset in meters
};

The position of the camera is also stored like this, and when it’s time to render you do something like this:

void
getRelativePosition(float& x, float& y, float& z, const Position& origin, const Position& object) {
    x = (object.kilometers[0] - origin.kilometers[0]) * 1000.0f +
        (object.offset[0] - origin.offset[0]);
    //Ditto for y and z
}

//Somewhere later
float x, y, z;
getRelativePosition(x, y, z, camera.position(), object.position());
renderMesh(x, y, z, object.mesh());

(For simplicity I ignored the orientation of camera and objects in this example, since there are no special problems associated with this).

If you’re working with a continuous world on a galactic scale you can replace the kilometers parameter with a long long (64 bits) giving you an effective range of 1.8 million lightyears.

EDIT: To use this for continuous geometry such as terrain etc, you have to split the terrain into chunks of size one square kilometers, the coordinates of the vertices in the terrain chunk should be in the range [0, 1000].

Also in the function getRelativePosition above you could change it so it returns a bool and return false if the difference in kilometers is larger than some threshold (say the distance to your far clip plane).