SLIDE Implementation Specification

SLIDE Class Hierarchy

The following is a diagram of the SLIDE C++ class hierarchy. Subclasses point up to their superclasses. Every textual SLIDE language element has a corresponding C++ class which represents its type in the run time viewer program. Notice that most SLIDE types are directly or indirectly a subclass of CSLIDEPrimitive.

Notice that CSLIDEObject, CSLIDEGroup, and CSLIDEInstance all share a common superclass, CSLIDENode. This common CSLIDENode type eases the management of the scene graph DAG.

Notice that CSLIDERotate, CSLIDEScale, and CSLIDETranslate all share a common superclass, CSLIDETransform. This common CSLIDETransform type eases the management of transforms in the CSLIDEInstance class.

Each of the values in the point statement, the rotate statement, the scale statement, the translate statement, and the color field of the surface statement can be replaced by a TCL expression enclosed in curly braces.

The classes which appear in red have had portions of their implementations removed. You need to complete the functionality of these classes.

Data Structures

The following diagram gives a rough idea about what data is contained in each of the data types. The linkage of the data types is arranged the way a normal scene would dictate. Note that this is not a complete listing of the data contained in each class, and in some cases there are classes displayed which you will be encountering this week (ignore these for now).

Outline of Viewer Execution

For more information and diagrams checkout the SLIDE Rendering Pipeline Page. Note: Ignore the rendering pass described there and follow the one described at the bottom of this page instead.

Loading and Preprocessing

1. Parse()
   • Builds all data structures.
2. CheckSemantics()
   • Dereferences all IDs.
   • Checks and runs global tclinit blocks (these will only be executed this one time).
3. Preprocess()
   • Preprocess all elements in this order:
     1. Surface
     2. Point
     3. Face
     4. Transform
     5. Instance
     6. Node (Object/Group/Camera/Light)
     7. Viewport
     8. Render
     On each element:
     • Invalidate bounding box.
     • Compress transforms at instances.
     • Call local TCL.
   • PreprocessGraph()

     For each CSLIDERender object's geometry root:

     • Calculates bounding boxes.
     • Identify dynamic subgraphs in scene hierarchy.
   • CreateDynamicsList()
     • Creates a dependency list on all dynamic objects and objects with dynamic bounding boxes. Elements occur in the dependency list in the same order as the preprocess order.
   • PreprocessWindow()
     • Creates TCL/TK window with TOGL widget drawing area.
4. RestartDynamics()
   • Sets time to t=0 and sets up first timer update callback.

Update Callback

1. Update()
   • Update the values of the viewer maintained TCL variables: SLF_TIME, SLF_MOUSE_X, and SLF_MOUSE_Y
   • Call the tclupdate blocks in the order in which they were encountered in the parsing of the SLIDE file.
   • Update all structures in the Dynamics list (The user should not count on the order in which different SLIDE entities are updated).
     On each element:
     • Call local TCL.
     • Invalidate bounding box.
2. UpdateGraph()
   • Call UpdateGraph() on all CSLIDERender objects' geometry roots.
     On each graph node:
     • Recursively compute new bounding box, if necessary.
3. Window::Update()
   • Calls PostRedisplay() on all windows.
4. Create the next Timer Callback
   • Set up next timer callback and go to sleep.

Render

1. Call Render() on each Viewport object
2. Recursively calls Render() on each Render object
3. Recursively calls Render() on each root Node object
4. Recursively calls Render() on each Instance
5. etc.

The following graph shows what should be happening for a single face in the rendering process, starting with the HandleDisplay callback on the CWindow object. Note that the matrix notation used in the diagram is ROW VECTOR form, and you will be coding COLUMN VECTORS in the project.

You can also download the postscript version of this graph: render.ps