Scene Graphs by wanghonghx

VIEWS: 15 PAGES: 31

									             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

								
To top