1 / 13

Implementing Scene Graphs, CSG Trees

Implementing Scene Graphs, CSG Trees. Glenn G. Chappell CHAPPELLG@member.ams.org U. of Alaska Fairbanks CS 481/681 Lecture Notes Monday, January 26, 2004. Review: Data Structures for Scenes. We will discuss four types of trees for holding scenes: Scene Graphs

Download Presentation

Implementing Scene Graphs, CSG Trees

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Implementing Scene Graphs,CSG Trees Glenn G. ChappellCHAPPELLG@member.ams.org U. of Alaska Fairbanks CS 481/681 Lecture Notes Monday, January 26, 2004

  2. Review:Data Structures for Scenes • We will discuss four types of trees for holding scenes: • Scene Graphs • Organized by how the scene is constructed. • Nodes hold objects. • CSG Trees • Organized by how the scene is constructed. • Leaves hold 3-D primitives. Internal nodes hold set operations. • BSP Trees • Organized by spatial relationships in the scene. • Nodes hold facets (in 3-D, polygons). • Quadtrees & Octrees • Organized spatially. • Nodes represent regions in space. Leaves hold objects. CS 481/681

  3. Review:The Basics of Scene Graphs [1/2] • Structure of a (simple) scene graph: • Each node corresponds to a drawable object. • The children of a given node correspond to “parts” of the object; these may be movable. • Thus, each node has a transformation. It, and all of its descendants, are drawn with this transformation. • The descendants have, in addition, their own transformations. • Data needed in each node: • Drawable object (pointer to this?). • Transformation (a matrix? a pointer to a matrix? a pointer to a function that returns a matrix?). • Pointers to child nodes. CS 481/681

  4. Review:The Basics of Scene Graphs [2/2] • In face.cpp, if we stored the face in a scene graph, it might look like this: • We can add functionality to scene graphs by putting other things in them. In particular: • Light sources. • Other things like light sources (e.g., environment maps). Head Hair Eye Eye Ear Ear Nose Mouth Iris Iris L. R. Pupil Pupil CS 481/681

  5. Implementing Scene Graphs:Overview • Now we look at how to implement a scene graph. • What type of tree to use. • The node data structure. • Drawing via a simple recursive traversal. • Deallocation issues. • Lastly, we look briefly at a “DAG” variation, in which we do not use a tree. CS 481/681

  6. Implementing Scene Graphs:Using B-Trees • We often implement an arbitrary tree as a binary tree. • We distinguish between the logical tree and the physical tree. The latter is the internal representation, which may be entirely hidden. • Each node has a “down” pointer to its first (logical) child and a “right” pointer to the next (logical) child of its (logical) parent. • Either or both of these may be null. • A pre-order traversal of the physical tree gives a reasonable (pre-order, roughly speaking) traversal of the logical tree. Logical Tree Physical Tree CS 481/681

  7. Implementing Scene Graphs:Node Implementation • Say a node is an object of class SGNode. Each node needs: • An object:(Drawable *). • A transformation. • I will use an array of 16 GLdouble’s. You may want to do this differently. • Down pointer & right pointer: (SGNode *). class SGNode { public: // Lots of stuff here: constructor(s), etc. void drawtree() const; // Draw objects in my subtree. private: Drawable * object; // Must be valid. GLdouble transform[16]; // Handle differently?? SGNode * downp; // Each of downp, rightp is SGNode * rightp; // either valid or null. }; CS 481/681

  8. Implementing Scene Graphs:Drawing Via Tree Traversal • Now writing drawtree is easy: recursively traverse the tree. • Stuff hanging off of downp uses this node’s transformation, but stuff hanging off of rightp does not. void SGNode::drawtree() const { glPushMatrix(); glMultMatrixd(transform); // Handle differently?? object->draw(); // virtual function call if (downp) downp->drawtree(); glPopMatrix(); if (rightp) rightp->drawtree(); } • Draw the scene by calling drawtree for the root node. CS 481/681

  9. Implementing Scene Graphs:The Node Destructor • Everything needs to be deallocated. Generally, in a tree, each node is responsible for freeing its children. SGNode::~SGNode() { // Is the node responsible for delete'ing its object? // If not, then you don't want the line below. delete object; // transform is just an array member; we can ignore // it here. But if your transformation uses dynamic // allocation, you should probably deallocate it now. if (downp) delete downp; if (rightp) delete rightp; } CS 481/681

  10. Implementing Scene Graphs:DAG Variation • A Directed Acyclic Graph (DAG) is a generalization of a tree. • Different nodes can share children. • Thus, a node may not have a unique parent. • We do not allow “cycles”: a node cannot be its own descendant. • The 2-child-pointer idea does not work for a DAG. (Why not?) • DAG’s are particularly appropriate for scene graphs, since identical objects can appear more than once in a scene. • This means that an object cannot store its own transformation. Instead, it stores the transformations of its children. • Deallocation gets interesting; a parent no longer “owns” its children. • Solution 1: Each node keeps a reference count. When it hits 0, deallocate. • Solution 2: Nodes do not manage each other at all. Keep all nodes in a list. CS 481/681

  11. CSG Trees:Introduction to CSG • We have constructed scenes with polygons (and points & lines). • Another method is Constructive Solid Geometry (CSG). • In CSG, primitives are solid 3-D objects. For example, • Sphere • Cube • Cylinder • Cone • Etc. … • We create new objects from existing ones using three set operations: • Union • Intersection • Set difference • CSG does not work well with pipeline-based rendering, so we will say little about it right now. • CSG scenes are typically rendered using some type of ray tracing. • The movie Tron (Disney, 1982) used CSG-style techniques. • CSG is less mainstream than it used to be. • I am told it is still used in CAD. CS 481/681

  12. CSG Trees:Scene Representation • In CSG, we represent a scene as a binary tree. • Leaves hold primitives. • Internal nodes, which always have two children, hold set operations. • The order in which children are given matters (for the set-difference operation). • CSG trees are useful for things other than rendering. • Intersection tests (collision detection, etc.) are not too hard. (Thus: ray tracing.) • A DAG may be appropriate here as well. U U U ∩ – sphere sphere cube cone sphere cube CS 481/681

  13. A Brief Introduction to BSP Trees • A very different way of storing a scene is a Binary Space Partition tree (BSP tree). • BSP trees are useful for visibility-related issues, HSR, etc. • Nodes hold polygons. • In 3-D nodes hold polygons. In 2-D they would hold line segments. • Thus, a BSP tree provides a relatively low-level description of a scene. • Data about the arrangement of the scene is encoded in the structure of the tree. • Details on the board … CS 481/681

More Related