# Scene Graphs by wanghonghx

VIEWS: 15 PAGES: 31

• pg 1
```									             Scene Graphs
• In 3D Graphics programming the
structure used is a scene graph which is
special tree structure designed to store
• Typical elements include
– geometries
– positional information
– lights
– fog
Recap
• 3D viewing is similar to taking picture
with camera:
– 2D view of 3D scene                                    2D picture

Camera
Content of 2D picture will depend on:
• camera parameters (position,
direction, field of view, ...),
• properties of scene objects,
• illumination, ...
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?)
ym      yw            ym

xm                  xm
zm                   zm
Bird model                            xw

z
Coordinate Systems
• Viewing coordinate system: reference frame for
specification of scene from viewpoint of
camera / viewer                          yv
yw              ym
ym                                        Camera
zv
xv
xm                    xm
zm                   zm
xw
Taking a view of scene
Viewing Pipeline
Coordinate transformations:                                    2D picture
– generation of 3D view involves sequence
y
(pipeline) of coordinate transformations v
yw
ym
ym
xv       Device
xm                         zv                coordinates
xm               Camera
zm         zm    ym
Viewing coordinates
xm          xw
zm

zw             3D object             World coordinates

Modelling 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:

World
Objects

Robot
Instancing

Mouth          Eye           Leg   Trunk   Arm   Legend
Traversing the Scene Graph
• Traverse the scene graph in depth-first order,
concatenating and undoing transforms:
– For example, to render a robot
–Render mouth
–Render eye
–Render eye
•Apply robot-to-body matrix
The Scene Graph in OpenGL
• OpenGL maintains a matrix stack of
modeling and viewing transformations:
Robot
Visited
Unvisited
Mouth          Eye      Leg    Trunk   Arm
Matrix
Active         Stack
Foot
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);
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
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
Data Structures
of objects

Computer graphics                                       Objects
of facets
often use hierarchical
Facets
Note:                                of vertices
other possible levels: object groups,
Structures
facet groups (surfaces), edges
vertex may also link back to facets      with x, y, z   Vertices
which share vertex (for shading)        coordinates
Data Structures
Object 1         Object 2           Object N

Object list

Facet 1                                 Facet M

Facet lists
Vertex array

Vertices
Facet list and
vertex array
Possible architecture
Data Structures
/* 3D point or vertex with integer coordinates */
typedef struct structTag3DiPoint
{
int xCoordinate,        /* x coordinate */
yCoordinate,        /* y coordinate */
zCoordinate;        /* z coordinate */
}      int3DPoint,      /* 3D point */
* pInt3DPoint,     /* pointer to a 3D point */
int3DVertex,     /* 3D vertex */
* pInt3DVertex;    /* pointer to a 3D vertex */

Possible structure for 3D point or vertex
Data Structures
/* Polygon in 3D space */
typedef struct structTag3DiPolygon
{
int3DVertex      i3SidedPoly[3];
int              colour,
visibilityFlag;
float            magNormal;

/* Other attributes can go here */
}    int3DPolygon,      /* 3D Polygon */
* pInt3DPolygon,     /* pointer to a 3D Polygon */
int3DFacet,        /* 3D facet */
* pInt3DFacet;       /* pointer to a 3D facet */
Possible structure for polygon
Data Structures
/* Object in 3D space */
typedef struct structTag3DiObject
{
pInt3DFacet      pFacetList;
pInt3DVertex     pVertexArray;
int              numVertices;

int3DPoint         worldPosition;

/* Other attributes can go here */
}      int3DObject,      /* 3D Object */
* pInt3DObject;     /* pointer to a 3D Object */

Possible structure for 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

Instances
Master
Data Structures
Object 1         Object 2             Object N

Instances         tm att           tm att              tm att

Master 1                                 Master M

Masters           car                                   ball

Facet list                            Facet list

Edge list                            Edge list
tm: transf. matrix
att: attributes       Vertex list                          Vertex list
Possible architecture
Tree structures to accommodate
scene graphs
•   Binary 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
•   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