CS488 - Introduction to Computer Graphics - Lecture 14

Mouse Interface

Model-View-Controller

Model

The application logic

• does not interact directly with the user
• receives input from controller
• updates its data structures
• provides output to view

View

Presentation of the model to the user

• receives a scene from the model
  • shared data synchronized using handles
• puts the scene onto the output devices
  • visual, audio, tactile, etc
• translates from world to device coordinates

Controller

Provision of interpreted (more or less) input to the user

• gets raw input from user actions on input devices
  • i.e., in screen coordinates
• has to communicate the input in language the model understands
  • e.g., gets screen coordinates from input device
    sends the `name' of a scene element to the model

Complication

Usually the view knows where in screen coordinates it put each scene element

• package the two together

Picking

For assignment 3 you need to be able to select graphical objects with the mouse

The simple principle

1. Mouse gives (x, y).
2. Render pixel at (x, y ) keeping track of the polygon it comes from.
3. Associate polygon with object

For the assignment let GL do it for you.

• Associate names (unsigned integers) with objects that are drawn
• Get back a hit stack, with primitives `near' where the mouse clicked
• It's up to you how you handle the hit stack.

See the notes.

Rotation

For assignment 3 you need to be able to rotate with the mouse

The virtual trackball

• vertical motion rotates about y
• horizontal motion rotates about x
• circular motion outside the trackball rotates about z

You need to modify the sample code.

Hierarchical Models

What we have

How to render any polygon anywhere

1. Put the polygon where you want it to be in world coordinates
2. Transform to view coordinates
3. Perspective transform
4. Clip in normalized device coordinates.
5. Scan convert each polygon in any order, using z-buffer to remove occuded pixels

What we want to have

Objects made of polygons that we can feed into the rendering pipeline.

• Making the objects is called modelling.
• Here we discuss the data structures and algorithms associated with hierarchical modelling
• Hierarchical is a synonym for `divide and conquer'.

Argument by example

Suppose you are modelling classical temples. How do you do it?

1. Open up Vitruvius. You will find that all temples are assumbled from a few basic parts, such as
   • shafts, bases, capitals
   • stylobates, stereobates
   • architraves
   • etc.
2. You don't know the words, but there are drawings with dimensions.
3. There are rules for making them bigger and smaller, so you think of scaling matrices.
4. There are rules for putting them in different orientations, so you think of rotation matrices.
5. There are rules for placing them in different locations, so you think of translation matrices.

At this point you can make a temple, but it's a lot of work. To make it easier, divide and conquer

1. Column = base + shaft + capital. Reuse this as a unit.
2. Entablature = architrave + frieze + cornice. Reuse this as a unit.

You get the idea. The result is

• a data structure called an acyclic directed graph, DAG,
  • which is like a tree designed for computer graphics.
  • This is a joke: a tree defined for computer graphics has only one leaf, which has to do a huge amount of photosynthesis.

What does this look like?

Scene -> First temple -> Stylobate
                      -> First column -> Generic column -> Base
                                                        -> Shaft
                                                        -> Capital
                      -> Second column
                      -> ...
                      -> Entablature
      -> Second temple /
                       -> First column /

Make a scene

proc scene
  multMatrix(P)
  multMatrix(V)
  pushMatrix( )
    multMatrix(T1)
    temple( )
  popMatrix( )
  pushMatrix( )
    multMatrix(T2)
    temple( )
  popMatrix( )
  etc.
 

Make a temple

proc temple( )
  pushMatrix( )
    multMatrix(SB)
    stylobate( )
  popMatrix( )
  pushMatrix( )
    multMatrix(C1)
    column( )
  popMatrix( )
  pushMatrix( )
    multMatrix(C2)
    column( )
  popMatrix( )
  ...
  pushMatrix( )
    multMatrix(En)
    entablature( )
  popMatrix( ) 

We don't want always to write a program, so we encapsulate the program as data.

Traverse a DAG

traverse( root )

proc traverse( node ) {
  if ( primitve( node ) ) {
    draw( node )
  } else { for each child {
    traverse( child )
  }
}

Build a DAG

scene = gr.transform( )

temple1 = gr.transform( )
gr.add_child( temple1, scene )
gr.set_transform( temple1, gr.translation(...)*gr.rotation(...)
gr.set_material( temple1, marble )
...

stylobate1 = gr.transform( )
floor = gr.cube( )
gr.add_child( stylobate, floor )
gr.add_child( temple1, stylobate )
gr.set_transform( stylobate, gr.scaling(...) )
column1 = gr.transform( )
gr.add_child( temple1, column1 )
gr.set_transform( column1, gr.translation(...)*gr.scaling(...)
...

Return to:

• Bill Cowan's home page
• Bill Cowan's teaching page.
• Bill Cowan's CS488 page.
• Bill Cowan's CS488 page for Winter 2009.
• Bill Cowan's CS488 lecture note page for Winter 2009.