1 / 35

Graphics Programming

Explore the fundamentals of interactive graphics programming at Hofstra University, focusing on the use of OpenGL and the GLUT toolkit. Learn about early innovations such as Ivan Sutherland's Sketchpad, basic interaction paradigms, and the distinction between logical and physical input devices. Understand the characteristics of different input modes—request, sample, and event—and how they shape application interaction. With hands-on coding examples, students will create interactive applications that respond to user inputs, demonstrating the importance of callback functions and event-driven programming.

yitro
Télécharger la présentation

Graphics Programming

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. Graphics Programming Input and Interaction Hofstra University

  2. Interaction • Early 60’s, Ivan Sutherland’s Project Sketchpad • Basic Paradigm: User see an image, reacts with an interactive device, image changes in response to input, . . . Hofstra University

  3. Interaction • OpenGL does not support interaction directly • Increase portability – work in a variety of environments • Windowing and input functions left out of API – emphasis on rendering • Use toolkits, GLUT Hofstra University

  4. Physical Input Devices • Pointing Device – indicates position on screen • Keyboard Device – return character codes to a program Hofstra University

  5. Logical Input Devices Major Characteristics: • What measurements the device returns to the program • When the device returns those measurements Hofstra University

  6. Application Input • Measure - what the device returns to the program • Trigger – signal send to the computer • Three distinct modes defined by the relationship between the measure process and the trigger. • Request Mode, Sample Mode, Event Mode Hofstra University

  7. Request Mode • The measure of the device is not returned to the program until the device is triggered Hofstra University

  8. Sample Mode • Measure is returned immediately after the function is called in the user program (device sample). • No trigger needed • Useful in apps where the program guides the user Hofstra University

  9. Event Mode • Can handle multiple inputs • When device triggered an event is generated • Identifier for device placed in the event queue • Event queue process is independent of the application, asynchronous • A callback function associated with a specific type of event Hofstra University

  10. Event-Driven Programming • Callback functions implement how the application program responds to events • Examples, each of the events below needs a callback function to handle it.Pointing EventsWindow EventsKeyboard EventsDisplay & Idle Events Hofstra University

  11. Pointing Device • Almost always a mouse • Move event – when mouse is moved with button depressed; • Passive Move Event – move without pressing button • Mouse Event – mouse button is depressed or releasedglutMouseFunc (mouse); Hofstra University

  12. Pointing Device – Mouse Callback void mouse(int btn, int state, int x, int y) { if (btn==GLUT_RIGHT_BUTTON && state==GLUT_DOWN) exit(0); } Depressing the right Button terminates the program Hofstra University

  13. Register callbacks int main(int argc, char** argv) { glutInit(&argc,argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutCreateWindow("square"); myinit (); glutReshapeFunc (myReshape); glutMouseFunc (mouse); glutMotionFunc(drawSquare); glutDisplayFunc(display); glutMainLoop(); } Called whenever thewindow is resized Hofstra University

  14. Window Events(Resizing – Dragging) • Redraw all the objects? • How do we handle aspect ratio? • Change size of attributes and primitives? Hofstra University

  15. Square Program Example • This program illustrates the use of the glut library for interfacing with a Window System • The program opens a window, clears it to black,then draws a box at the location of the mouse each time the left button is clicked. The right button exits the program • The program also reacts correctly when the window is moved or resized by clearing the new window to black Hofstra University

  16. Global Variables /* globals */ GLsizei wh = 500, ww = 500; /* initial window size */ GLfloat size = 3.0; /* half side length of square */ • Size of window • Viewport position and size • Size of clipping window Hofstra University

  17. Window Event – Reshape Example:change clipping wndw to match screen wndw, viewport matches new aspect ratio, whole screen wndw void myReshape(GLsizei w, GLsizei h) { /* adjust clipping box */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, (GLdouble)w, 0.0, (GLdouble)h, -1.0, 1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); /* adjust viewport and clear */ glViewport(0,0,w,h); glClearColor (0.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); glFlush(); /* set global size for use by drawing routine */ ww = w; wh = h; } reshaping routine called with glutReshapeFunc (myReshape); whenever window is resized or moved Hofstra University

  18. Pointing Device – Motion Callback Example:whenever mouse dragged and button down draw random color square at the mouse position Called with glutMotionFunc(drawSquare);if button held down void drawSquare(int x, int y) { y=wh-y; glColor3ub( (char) rand()%256, (char) rand()%256, (char) rand()%256); glBegin(GL_POLYGON); glVertex2f(x+size, y+size); glVertex2f(x-size, y+size); glVertex2f(x-size, y-size); glVertex2f(x+size, y-size); glEnd(); glFlush(); } Hofstra University

  19. Keyboard Events void keyboard(unsigned char key, int x, int y) { if (key=='q' || key=='Q') exit(0); } glutKeyboardFunc(keyboard); Hofstra University

  20. Window Management id=glutCreateWindow(“second window”); glutSetWindow(id); Hofstra University

  21. Menus • Pop-up menus • Common Steps: • Define the entries • Link the menu to a mouse button • Define callback function Hofstra University

  22. Registering a menu callback and defining a menu identifier passed to callback • glutCreateMenu(demo_menu); • glutAddMenuEntry(“quit”, 1); • glutAddMenuEntry(“increase square size”, 2); • glutAddMenuEntry(“decrease square size”, 3); • glutAttachMenu(GLUT_RIGHT_BUTTON); • demo_menu is the callback function for the menu • The menu appears on right-button mouse click Hofstra University

  23. Menus void demo_menu(int id) { if (id==1) exit (0); if (id==2) size = 2* size; else if (size > 1) size = size/2; glutPostRedisplay( ); } Hofstra University

  24. Hierarchical Menus top_menu size_menu Hofstra University

  25. Hierarchical Menus • GLint sub_menu = glutCreateMenu(size_menu); • glutAddMenuEntry(“increase square size”, 1); • glutAddMenuEntry(“decrease square size”, 2); • glutCreateMenu(top_menu); • glutAddMenuEntry(“quit”, 1); • glutAddSubMenu(“Resize”, sub_menu); • glutAttachMenu(GLUT_RIGHT_BUTTON); • top_menu and size_menu are callback functions for the top- and the sub-menus, respectively Hofstra University

  26. Animation: Using idle callback and double bufferingExample Rotating Cube Program • We want to create animation • We continuously keep changing the value of Hofstra University

  27. Spin the square: globals #define PI 3.141592 GLdouble theta = 0; // rotation angle GLsizei wnd_w = 500; // display window width GLsizei wnd_h = 500; // display window height GLfloat spin_speed = PI/180; // incerement for angle in rad Hofstra University

  28. Spin square: prototypes void help(); //print instructions void myinit(); // OpenGL init void display(); // display callback void myreshape(GLsizei, GLsizei); // reshape callback void update_angle(); // idle callback void control_speed(GLubyte, GLint, GLint); // keybrd callback Hofstra University

  29. Spin square: reshape callback /* keep the viewport aspect ratio 1, so square does not get distorted */ void myreshape(GLsizei w, GLsizei h) { wnd_w = w; wnd_h = h; if (h < w) w=h; // adjust viewport (to preserve aspect ratio 1), and clear. glViewport(0, 0, w, w); glutPostRedisplay(); } Hofstra University

  30. Spin square: keyboard callback // keyboard callback increase speed, decrease speed or quit void control_speed(GLubyte key, GLint x, GLint y) { switch (key) { case('q'): case('Q'): exit (0); break; case('s'): case('S'): spin_speed *=2; break; case('d'): case( 'D'): spin_speed /= 2; } glutPostRedisplay( ); } Hofstra University

  31. Spin square: idle callback // idle callback void update_angle(void) { theta += spin_speed; if (theta>2*PI) theta-= 2*PI; glutPostRedisplay(); } glutIdleFunc(update_angle); Hofstra University

  32. Double Buffering • A complex display may not be drawn in a single refresh cycle • Double Buffering solves the problem • Assume two frame buffers: front buffer and back buffer • Swap these from the application program invoking a display callback Hofstra University

  33. Spin square: double buffering void display() { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POLYGON); glColor3f(1.0, 0.0, 0.0); glVertex2d(cos(theta), sin(theta)); glColor3f(0.0, 0.1, 0.0); glVertex2d(-sin(theta), cos(theta)); glColor3f(1.0, 0.0, 1.0); glVertex2d(-cos(theta), -sin(theta)); glColor3f(1.0, 1.0, 0.0); glVertex2d(sin(theta), -cos(theta)); glEnd(); glutSwapBuffers(); } Hofstra University

  34. Spin square: register callbacks int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); glutInitWindowSize(wnd_w,wnd_h); glutInitWindowPosition(0,0); glutCreateWindow("spinning square, speed control with menu"); myinit(); glutDisplayFunc(display); glutReshapeFunc(myreshape); glutIdleFunc(update_angle); glutKeyboardFunc(control_speed); glutMainLoop(); return 0; } Hofstra University

  35. Good Interactive Programs • Smooth display • Interactive devices • Variety of methods to input data • Easy-to-use interface • Feedback to user (help) • Human consideration (HCI) Hofstra University

More Related