Graphics
Building Computer and Viewing an Interactive Scene Transformations
CS 437
CG tasks
A computer graphics program has to take care of the following main tasks
Build a scene, or a sequence of scenes (animation) View the scene Facilitate interaction with the user and the windowing system
The basic structure of the prototype OpenGL program reflects these tasks
CS 437
Program structure
void main(int argc, char** argv ) { glutInit(&arg, argv) glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE ); //set display mode glutInitWindowSize(700,700); //initial size in pixels glutInitWindowPosition(0,0); //initial position glutCreateWindow( Program Template ); init(); //additional initialization (could include modeling and viewing related code) glutDisplayFunc( display ); //Scene building and viewing glutKeyboardFunc( key ); //Interaction glutReshapeFunc( resize ); //Responds to changes of the physical window glutIdleFunc( idle ); //Animation related computations glutMainLoop(); }
CS 437
Summary
SG stages. Transformation pipeline. Outline several approaches to building a scene. More advanced techniques in particular advanced techniques for improved the appearance will be covered later in the course.
CS 437
Building and Viewing a Scene
The dominant approach to this task is to it break in parts
Construct shapes from geometric primitives, thereby creating mathematical descriptions of objects. Arrange the objects in three dimensional space and select the desired vantage point for viewing the composed scene. Calculate the color of all the objects. The color might be explicitly assigned by the application, determined from specified lighting conditions, or obtained by pasting a texture onto the objects.
This process involves different coordinate systems and coordinate transformations. The detailed math machinery will be presented in later modules. The following example illustrates the basic concepts and ideas.
CS 437
Step by step
Construct shapes from geometric primitives, thereby creating mathematical descriptions of objects. Arrange the objects in three dimensional space and select the desired vantage point for viewing the composed scene. Calculate the color of all the objects. The color might be explicitly assigned by the application, determined from specified lighting conditions, or obtained by pasting a texture onto the objects. Convert the mathematical description of objects and their associated color information to pixels on the screen. This process is called rasterization. During these stages, an API might perform other operations, such as eliminating parts of objects that are hidden by other objects.
CS 437
The Rendering
Getting this rendering: a topdown approach Build the scene. It consists of three objects defined in terms of the scene/world coordinate system.
Build each object separately its representation is w/r to specific object-related coordinate system Put together the scene by placing the objects appropriately
Specify the viewer
CS 437
World Coordinates and Model Coordinates
objects
CS 437
World/scene
Building the scene by positioning objects in it. Involves modeling transformations
CS 437
Modeling transformations
CS 437
Viewing the World
Once the world is build one can introduce the camera
World
World viewed by a camera
CS 437
Viewing Transformation
The World The Cameras View of the World
CS 437
Transformations and Attributes
Model View Transformation (MVT)
Model transformations: Position objects inside the scene. The MT are composed of translations, scaling, rotations. Viewing Transformation: Specifies the position and orientation of "the view" (i.e., eye or synthetic camera). There is only one viewing transformation and it is applied to ALL vertices of all 3D objects in a scene. It is composed of a translation and one or more rotations.
Specifying additional attributes, like color, material properties, lights, shading, viewport is needed to obtain the rendering. Projection transformation: define the camera and its attributes: view volume, focus length, projection mode lead are used in clipping and culling, projection.
CS 437
MVT, Lights, Material, Shading, Rendering
CS 437
Today
Coordinate systems and transformations The matrix pipeline Modeling: Building a scene Symbols and instancing Hierarchical models Attributes and rendering states (see pages 14 to 32 of the previous lecture.)
Animation
CS 437
Coordinate Systems in CG
Object/Model World/Scene Camera/eye/viewer Image/Normalized View Volume Screen Pixel
CS 437
Rendering and the Transformation Pipeline
The rendering process in most APIs amounts to passing all the primitives (vertices determining them) trough a sequence of transformations. This process is implemented as a pipeline of transformations. The transformations are represented as matrices, and one usually speaks of the matrix pipeline.
CS 437
The Transformation Pipeline
The Current Transformation (CT) Later Modules
Vertex data
Modelview Transform (MVT) Eye coord data
Projection Transform (PT) clip coord data
CS 437
Perspective division
Viewport map
NDC
Window coordinates
Current Transformation
CTmatrix=PTmatrix*MVTmatrix. State component MVT and PT are usually part of the current state Matrix Stacks in OpenGL: used in manipulation and (re)positioning of objects See OpenGL Programming Guide, 4th edition, Chapter 3 Viewing, pages 111-143
CS 437
Building Scenes and Transformations in OpenGL
It is done in the display function which is used to process a redisplay event. If one uses GLUT, then the function is registered via glutDisplayFunc. Building the scene and positioning the camera (viewer) is achieved by modifying the MODELVIEW matrix. The transformation matrices can be loaded explicitly (e.g. glLoadMatrix) or by specifying the operations they perform (e.g., glRotate, glTranslate). Note that building an object is usually viewed as building a scene, so the same ideas apply.
CS 437
Transformations in OpenGL
We discussed this in the previous class. Notes TBP
CS 437
Modeling, Scene Graphs
CS 437
Possible approaches
Symbols and instancing, instancing transforms: can be represented by a table. Hierarchical modeling. Scene graphs (SG).
(Scene) Trees DAG
CS 437
Symbols & Instances
CS 437
Instancing in OpenGL
In OpenGL, instancing is created by modifying the model-view matrix:
glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glPushMatrix( ); glTranslatef( ... ); glRotatef( ... ); glScalef( ... ); symbol(); glPopMatrix( );
CS 437
Village code
glMatrixMode(GL_MODELVIEW); glLoadIdentity(); setview(); //instance 1 Basic simple house glPushMatrix(); house(); glPopMatrix(); //simple house instance 2 Big house Translated glPushMatrix(); glTranslatef(6, 0, 0); glScalef(2,2,2); house(); glPopMatrix(); //simple house instance 3 Intermed. house Rotated 15deg and Translated glPushMatrix(); glTranslatef(0, 6, 0); glRotated(15, 0,0,1); glScalef(2,1,1); glPopMatrix(); house(); //david house Instance 1 glPushMatrix(); glTranslatef(-6,0,0); glScalef(2,2,2); david_house(); glPopMatrix(); glutSwapBuffers(); CS 437
Hierarchical modeling
Objects are grouped hierarchically according to spatial location.
Natural for many objects (think of a human body, a car, a city) Locality of reference: important in memory management. Objects of current interest often occur in the same spatial region. SG enable us to eliminate other regions from further processing (important in rendering, collision detection) Persistence issues: saving a scene can be done recursively (each node save itself)
The symbol/instance paradigm is like a tree of depth one.
CS 437
Trees vs DAG
DAG allow high-level sharing of objects but often make the memory costs and code complexity too high. DAGs are natural in many applications, e.g., modeling polygonal meshes where many edges and vertices are shared by higher level objects.
CS 437
DAG example: polygonal mesh
surface
Polygon 1
Polygon 2
Polygon 3
Polygon n
Edge 1
Edge 2
Edge 3
Vertex 1
Vertex 2
Vertex 3
CS 437
Hierarchical Modeling and Structures Primitives that can be drawn directly, at leaves Internal nodes become instances Transformations that position instances of objects label the edges Traverse in pre-order (left to right, depthfirst).
Stack based implementation Model independent traversal algorithm
CS 437
Example: simple 2D drawing
CS 437
Hierarchical modeling: tree of transformations
T1.T2.T5.T7.T9(LINE)
Final picture, obtained by traversing in pre-order the tree
CS 437
Compress the tree
If an edge (A,B) is labeled with identity transformation, remove it , and move any drawings from node B into A If edges (A,B) and (A,C) have the same labels, merge the nodes B and C Example: in the previous tree T8 will be removed, and the unit square moved to the parent node
CS 437
Model to OpenGL code: Stack based implementation
Start from the root, traverse tree in pre-order When visiting a node, if there is a primitive at the node that can be drawn, draw it If going down from a node which has more then one unvisited child, store(push) CTM and attributes before continuing down If coming back up an edge to a node which has unvisited children, pop CTM and attributes Mixes DS with implementation, it is hard wired to the example, dynamic use is clumsy
CS 437
The scene
glScalef(1.0,-1.0,1.0); //T1 glPushMatrix(); glTranslatef(1.5, 3.0, 0.0); //T2 glScalef(1.0, 2.0, 1.0); //T5 glBegin(GL_LINE_LOOP); //BOX glVertex3f(0.0,0.0,0.0); glVertex3f(1.0,0.0,0.0); glVertex3f(1.0,1.0,0.0); glVertex3f(0.0,1.0,0.0); glEnd(); glTranslatef(0.5,0.0, 0.0); //T7 glRotatef(90.0,0.0,0.0,1.0); //T9 glBegin(GL_LINES); //LINE glVertex3f(0.0,0.0,0.0); glVertex3f(1.0,0.0,0.0); glEnd(); glPopMatrix(); glPushMatrix(); glTranslatef(2.0,1.0,0.0); //T3 glScalef(0.5, 0.5, 1.0); //T6 drawUnitCircle(NUM_SLICES); glPopMatrix(); glScalef(4.0,5.0,1.0); // T4 glBegin(GL_LINE_LOOP); // BOX glVertex3f(0.0,0.0,0.0); glVertex3f(1.0,0.0,0.0); glVertex3f(1.0,1.0,0.0); glVertex3f(0.0,1.0,0.0); glEnd(); glFlush();
CS 437
Model independent traversal algorithm
All information is stored in the nodes:
(Pointer to a) drawing function Transformation positioning the node w/r to its parent (the local transform matrix LTM) Pointer to right sibling Pointer(s) to child(ren) Attributes color, shading info, bounding volume,.
State nodes and scene graphs (see later)
CS 437
Tree node
typedef struct treenode{ GLfloat m[16]; GLfloat clr[3]; int display_list_id; struct treenode *child; struct treenode *sibling; } treenode;
CS 437
Traversal function
void traverse(treenode* root){ if (root==NULL) return; glPushMatrix(); glPushAttrib(.); glMultMatrixf(root->m); glColor3f((root->clr)[0],(root->clr)[1],(root->clr)[2]); glCallList(root->display_list_id); if(root->child != NULL) traverse(root->child); glPopMatrix(); glPopAttrib(); if(root->sibling != NULL) traverse(root->sibling); }
CS 437
Display function
void display(){ glClear(GL_COLOR_BUFFER_BIT); glLoadIdentity(); traverse(&root_node); glFlush(); }
CS 437
Basic tasks
Set up the tree Define t...