Coordinate System Fundamentals

A coordinate system serves as a framework for precisely positioning objects within a scene. All geometric transformations occur relative to specific coordinate systems.

Common coordinate systems include world coordinates, object coordinates, and camera coordinates.

World Coordinate System

The worldd coordinate system, also known as the global coordinate system, describes all objects within the entire scene. It provides an absolute reference standard for object positions, functioning as an absolute coordinate system since all object locations are defined in absolute terms.

Object Coordinate System

The object coordinate system establishes an independent coordinate framework for specific objects, making it convenient to describe individual entities. For example, a modeler might create a human figure near the origin point, placing this model within its own object coordinate system.

Modelers typically don't concern themselves with where the model will be placed in the world. They simply need to create the character within the object coordinate system, then generate multiple animations. When 3D developers use the model, they transform it into world coordinates.

Camera Coordinate System

The camera coordinate system relates to the observer. While similar to screen coordinates, the key difference is that camera coordinates exist in 3D space, whereas screen coordinates exist in 2D space.

The camera coordinate system addresses the question: "Which objects should be rendered and displayed on screen?" This includes whether objects are within the camera's viewing region, rendering order, and occlusion culling.

Both OSG and OpenGL use left-handed coordinate systems where the X-axis points right, but OpenGL has Y-axis up and Z-axis toward you (perpendicular out of the screen), while OSG has Z-axis up and Y-axis perpendicular into the screen.

Coordinate Transformations

Object-to-World Transformation

Three-dimensional objects require a series of coordinate transformations to display correctly and realistically on screen.

Each object exists within its own object coordinate system. During rendering, each object transforms to world coordinates through transformation matrices.

How does OSG implement object-to-world transformation? OSG builds scene trees from nodes, where each node has parent nodes and transformation matrices. These matrices record how to transform from the node's coordinate system to its parent's coordinate system. Multiplying all transformation matrices between the target node and root node achieves the transformation.

Custom Node Visitor Implementation

Visitors traverse scene nodes and calculate world coordinates based on transformation paths. Here's an implementation demonstrating visitor usage:

#include <osgViewer/Viewer>
#include <osg/Node>
#include <osg/Geode>
#include <osg/Group>
#include <osgDB/ReadFile>
#include <osgUtil/Optimizer>

// Custom visitor class for accessing nodes and scene trees
// Inherits from osg::NodeVisitor
class WorldCoordCalculator : public osg::NodeVisitor
{
public:
    // Constructor initializes osg::NodeVisitor
    // TRAVERSE_PARENTS indicates visiting target node and its parents
    WorldCoordCalculator() : osg::NodeVisitor(NodeVisitor::TRAVERSE_PARENTS), 
                           calculationComplete(false)
    {
        worldTransform = new osg::Matrixd();
    }

    // Custom method for visiting nodes and scene trees
    virtual void apply(osg::Node& inputNode)
    {
        if (!calculationComplete)
        {
            // Though scenes appear as trees, they're actually directed acyclic graphs
            // since one node may have multiple parents
            if (0 == inputNode.getNumParents())
            {
                // No parents means we've reached root - calculate final world coords
                worldTransform->set(osg::computeLocalToWorld(this->getNodePath()));
                calculationComplete = true;
            }
            traverse(inputNode);
        }
    }
    
    osg::Matrixd* retrieveResult()
    {
        return worldTransform;
    }

private:
    bool calculationComplete;
    osg::Matrixd* worldTransform;
};

// Calculate final transformation matrix for a given node
osg::Matrixd* computeWorldCoordinates(osg::Node* targetNode)
{
    WorldCoordCalculator* calculator = new WorldCoordCalculator();
    if (targetNode && calculator)
    {
        targetNode->accept(*calculator);
        return calculator->retrieveResult();
    }
    else
    {
        return nullptr;
    }
}

Transformation Process Summary

Model vertex data exists in object coordinates. To transform models to the final screen display, vertices undergo: object coordinates (model transformations) → world coordinates (view-projection transformations) → clip space (viewport transformations) → screen coordinates.

Model and projection transformations move vertex data to normalized device coordinates, followed by viewport transformation to obtain screen window coordinates.