Get documents about "Scene Graphs
Document Sample
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
Camera paradigm for 3D viewing
• 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
Head model
xm xm
zm zm
Bird model xw
Scene (head looking at bird)
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
zw (head looking at bird)
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
Head Body (i.e, a matrix)
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
•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:
Robot
Visited
Head Body
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);
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
Linked list Scene
of objects
Linked lists
Computer graphics Objects
of facets
often use hierarchical
data structures, e.g. Linked lists
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;
struct structTag3DiPolygon * link2NextPolygon;
/* 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;
struct structTag3DiObject * link2NextObject;
/* 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
• 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
