Scene Graphs In 3D Graphics programming the structure used is a scene graph which is special tree structure designed to store information about a scene. Typical elements include –geometries –positional information –lights –fog

Recap 3D scene Camera 2D picture Content of 2D picture will depend on: camera parameters (position, direction, field of view,...), properties of scene objects, illumination,... Camera paradigm for 3D viewing 3D viewing is similar to taking picture with camera: –2D view of 3D scene

Introduction Main steps in 3D graphics viewing: Scene specification View specification –Specification of viewing parameters –Projection: scene mapped onto 2D view window –Clipping: removal of primitives that are outside Display

Coordinate Systems World coordinate system: reference frame for specification of (relative) position / orientation of viewer and scene objects (size?) xwxw zwzw ywyw Scene (head looking at bird) xmxm zmzm ymym Head model xmxm zmzm ymym Bird model

Coordinate Systems Viewing coordinate system: reference frame for specification of scene from viewpoint of camera / viewer xwxw zwzw ywyw xmxm zmzm ymym xmxm zmzm ymym Taking a view of scene (head looking at bird) Camera yvyv zvzv xvxv

xwxw zwzw ywyw World coordinates Viewing Pipeline Coordinate transformations: –generation of 3D view involves sequence (pipeline) of coordinate transformations Camera Modelling coordinates 3D object 2D picture Device coordinates xmxm zmzm ymym xmxm zmzm ymym xmxm zmzm ymym xvxv zvzv yvyv Viewing coordinates

A scene graph is a data structure used to hold the elements that make up a scene. It may be either a tree or a Directed Acyclic Graph (DAG). The tree and DAG are similar, except that in the DAG the branches may possibly grow back together.

Trees Start at the root and move outward towards the leaves. Normally shown with the root at the top and the branches at the bottom. A node is a part of this tree that may have other nodes or leaves underneath it, a leaf cannot have other nodes or leaves under it. There is only one path from a leaf to the root of the tree. There are no "cycles", if you move outward along the branches, you never loop back around to end up at the root again.

Directed acyclic graph (DAG) Directed means that the parent-child relationship is one-way, Acyclic means that there can’t be loops, i.e. child cant be one of its own ancestors Like a tree, except maybe the branches grow back together sometimes, so that following a different sequence of branches outwards from the root might lead you to the exact same leaf. Branches never grow in a loop, though, so as long as you keep moving outwards, you always end up at a leaf eventually:

Nodes The scene graph contains 'nodes' such as shape, light, camera, etc. The tree structure is important because it allows the scope of influence of scene parameters to be clear and unambiguous. Nodes which have an unspecified number of children below them are known as Group nodes. One of the most important type of nodes is a Transform Group, this modifies all of the shapes below it by transforming them via a 4x4 matrix.

The Scene Graph The scene graph captures transformations and object-object relationships in a suitable structure: Robot BodyHead ArmTrunkLegEyeMouth Objects Instancing (i.e, a matrix) Legend World

Traversing the Scene Graph Traverse the scene graph in depth-first order, concatenating and undoing transforms: –For example, to render a robot Apply robot -to-head matrix Apply head -to-mouth matrix –Render mouth Un-apply head-to-mouth matrix Apply head-to-left eye matrix –Render eye Un-apply head-to-left eye matrix Apply head-to-right eye matrix –Render eye Un-apply head-to-right eye matrix Un-apply robot-to-head matrix Apply robot-to-body matrix

The Scene Graph in OpenGL OpenGL maintains a matrix stack of modeling and viewing transformations: ArmTrunk Leg EyeMouth HeadBody Robot Foot Matrix Stack Visited Unvisited Active

OpenGL: The Matrix Stack The user can save the current transformation matrix by pushing it onto the stack with glPushMatrix() The user can later restore the most recently pushed matrix with glPopMatrix() These commands really only make sense when in GL_MODELVIEW matrix mode

OpenGL: Matrix Stack Example glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(…); // save translation matrix: glPushMatrix(); glRotatef(…); // render something translated & rotated: glCallList(foo); // restore pushed matrix, undoing rotation: glPopMatrix(); // render something else, no rotation: glCallList(bar);

Data Structures Let’s have a look at the data structures employed in more detail Selection of data structures for computer graphics often driven by need for efficiency –storage –computation Trade-off between storage and computational efficiency often applied

Data Structures Data structures are required for: –scene specification object, polygon, point / vertex,... –mathematical manipulations vector, matrix, … –graphical display buffer,... Typical data structures: trees / scene graphs, linked lists, arrays

Data Structures Computer graphics often use hierarchical data structures, e.g. Scene ObjectsFacetsVertices Linked list of objects Linked lists of facets Linked lists of vertices Structures with x, y, z coordinates Note: other possible levels: object groups, facet groups (surfaces), edges vertex may also link back to facets which share vertex (for shading)

Data Structures Possible architecture Facet lists Facet M Facet 1 Vertex array Vertices Object list Object 1Object 2Object N Facet list and vertex array

Data Structures Possible structure for 3D point or vertex /* 3D point or vertex with integer coordinates */ typedef struct structTag3DiPoint { intxCoordinate, /* x coordinate */ intxCoordinate, /* x coordinate */ yCoordinate, /* y coordinate */ yCoordinate, /* y coordinate */ zCoordinate; /* z coordinate */ zCoordinate; /* z coordinate */ } int3DPoint, /* 3D point */ } int3DPoint, /* 3D point */ * pInt3DPoint, /* pointer to a 3D point */ * pInt3DPoint, /* pointer to a 3D point */ int3DVertex, /* 3D vertex */ int3DVertex, /* 3D vertex */ * pInt3DVertex; /* pointer to a 3D vertex */ * pInt3DVertex; /* pointer to a 3D vertex */

Data Structures Possible structure for polygon /* Polygon in 3D space */ typedef struct structTag3DiPolygon { int3DVertexi3SidedPoly[3]; int3DVertexi3SidedPoly[3]; intcolour, intcolour,visibilityFlag; floatmagNormal; floatmagNormal; struct structTag3DiPolygon * link2NextPolygon; struct structTag3DiPolygon * link2NextPolygon; /* Other attributes can go here */ /* Other attributes can go here */ }int3DPolygon, /* 3D Polygon */ }int3DPolygon, /* 3D Polygon */ * pInt3DPolygon, /* pointer to a 3D Polygon */ * pInt3DPolygon, /* pointer to a 3D Polygon */ int3DFacet, /* 3D facet */ int3DFacet, /* 3D facet */ * pInt3DFacet; /* pointer to a 3D facet */ * pInt3DFacet; /* pointer to a 3D facet */

Data Structures Possible structure for 3D object /* Object in 3D space */ typedef struct structTag3DiObject { pInt3DFacetpFacetList; pInt3DFacetpFacetList; pInt3DVertexpVertexArray; pInt3DVertexpVertexArray; intnumVertices; intnumVertices; int3DPointworldPosition; int3DPointworldPosition; struct structTag3DiObject * link2NextObject; struct structTag3DiObject * link2NextObject; /* Other attributes can go here */ /* Other attributes can go here */ } int3DObject, /* 3D Object */ } int3DObject, /* 3D Object */ * pInt3DObject; /* pointer to a 3D Object */ * pInt3DObject; /* pointer to a 3D Object */

Data Structures To synthesise copies of an object –master / instance architecture master defines generic attributes of object instance defines attribute values of particular copy Master Instances

Data Structures Possible architecture Masters Instances Object 1 tmatt Object 2 tm att Master 1 car Facet list Edge list Vertex list Object N tm att tm: transf. matrix att: attributes Master M ball Facet list Edge list Vertex list

Tree structures to accommodate scene graphs Binary trees Quad trees Oct trees Child-sibling trees

Using Modelling Software Maya 3d Studio Max VRML generators

Features Primitives Groups Complex, irregular shapes Lines, Points, Facets Curved surfaces Texture mapped surfaces Lighting and Shading Interactions and Behaviours

Primitives Facets constructed from known geometric relationships Uses polygons to map to standard mesh structure Scaling, shearing, rotation and translation used to modify vertex information, vertex ordering remains same

Complex or Irregular objects Manual construction –Lines and vertices positioned by hand/ eye –Modification of primitives –Extrusions Curved surfaces –B-splines –Bezier curves –Parametric meshes –etc

Scene view Scene hierarchy required Must have mechanism to store results Output file structure must link to internal structure –Hierarchy –Relationship between hierarchical nodes –Vertex list –Vertex ordering list –Lighting information –Texture mapping –May also hold recent viewing parameters

3DS File structure May be ASCII output Tags outline structures Must read between Tags Comma delimitation usually to separate vertex list and ordering information