A primitive object is a simple object with

• a unit size
• a coordinate system positioned (usually) at the object centre
• a coordinate system aligned with the object's natural axes

A primitive circle would have

• diameter 1
• origin (0,0,0)
• axes x and y in the plane of the circle; axis z perpendicular to the circle

A primitive rectangle would have

• height 1, width 1
• origin (0,0,0)
• axes x and y in the plane of the rectangle; axis z perpendicular to the rectangle

A primitive sphere would have

• diameter 1
• origin (0,0,0)
• any axes, since the sphere is radially symmetric

A primitive cylinder would have

• length 1, diameter 1
• origin (0,0,0)
• axis z along the cylinder axis; axes x and y perpendicular to the cylinder axis

Pick the size and coordinate system to make the object easy to transform.

"Instancing" is the act of creating a copy (an "instance") of the object.

An instance can have different dimensions, positions, and orientation than the primitive object.

A primitive object can be scaled, rotated, and translated when creating an instance. This transformation can be represented as a $4 \times 4$ matrix, $M$.

To create an instance of a primitive object with vertices $v_0, v_1, v_2, \ldots$ transformed by a matrix, $M$, create (in OpenGL) a VBO in which the vertex positions are $M v_0, M v_1, M v_2, \ldots$.

See 02-hierarchical/rectangle.cpp and 02-hierarchical/cylinder.cpp in openGL.zip for examples of object instancing.

Objects are often represented hierarchically, with a "root" object that has "child" objects. Each child object can, itself, have child objects.

In the robot arm below, link $\ell_1$ has child $\ell_2$, and link $\ell_2$ has children $\ell_3$ and $\ell_4$.

The world can be thought of as an "object" which has, as its children, all the roots of all the hierarchical objects. In the robot arm above, the world has one child: the link $\ell_1$.

Each object stores:

• its own geometry
• a transformation from its coordinate system into the coordinate system of its parent
• a list of child objects

Child-to-Parent Transformations

Object-to-World Transformations

A hierarchical object can be rendered recursively. Recall that each object stores

• its own geometry
• a transformation from its coordinate system into the coordinate system of its parent
• a list of child objects

To render the "root" link $\ell_1$, the $\ell_1$-to-$WCS$ transformation is applied to all vertices of $\ell_1$, so that they are rendered in the $WCS$.

This can be done by passing in the $4 \times 4$ matrix $T^1_w$ to the GPU's vertex shader, which will apply the transform as the vertices of $\ell_1$ are being rendered.

To render link			Apply transformation
$\ell_1$			$T^1_w$
	$\ell_2$		$T^1_w \; T^2_1$
		$\ell_3$	$T^1_w \; T^2_1 \; T^3_2$
		$\ell_4$	$T^1_w \; T^2_1 \; T^4_2$

The transformations are accumulated as the hierarchy is traversed downward, so the accumulated transformations of the ancestors of an object should be given to the object when the object is rendered.

So each object, upon rendering, is given its accumulated "parent-to-$WCS$" transformation:

To render link			Apply transformation	parent-to-$WCS$ transformation	Object-to-parent transformation
$\ell_1$			$T^1_w$	$I$	$T^1_w$
	$\ell_2$		$T^1_w \; T^2_1$	$I \; T^1_w$	$T^2_1$
		$\ell_3$	$T^1_w \; T^2_1 \; T^3_2$	$I \; T^1_w \; T^2_1$	$T^3_2$
		$\ell_4$	$T^1_w \; T^2_1 \; T^4_2$	$I \; T^1_w \; T^2_1$	$T^4_2$

and the transformation applied to the object's vertices is the product of the parent-to-$WCS$ transformation ($T^P_w$) and the object-to-parent transformation ($T^O_P$).

In the following code to render a hierarchical object, Tpw is the parent-to-world transform and Tow is the object-to-world transform:

renderObject( object O, transformation Tpw )
    Tow = Tpw x O.object_to_parent_transform 
    drawGeometry( O.geometry, Tow )
    for each child, C, in O.children:
        renderObject( C, Tow )

See Object::draw() in 02-hierarchical/object.cpp for an example of hierarchical object rendering.