Presentation is loading. Please wait.

Presentation is loading. Please wait.


Similar presentations

Presentation on theme: "SUJAN CHOWDHURY Lecturer, CSE, CUET"— Presentation transcript:


2 What is OpenGL OpenGL is a software API to graphics hardware.
designed as a streamlined, hardware-independent interface to be implemented on many different hardware platforms Intuitive, procedural interface with c binding No windowing commands ! No high-level commands for describing models of three-dimensional objects The OpenGL Utility Library (GLU) provides many of the modeling features, such as quadric surfaces and NURBS curves and surfaces

3 SGI and GL Silicon Graphics (SGI) revolutionized the graphics workstation by implementing the pipeline in hardware (1982) To access the system, application programmers used a library called GL With GL, it was relatively simple to program three dimensional interactive applications

4 OpenGL The success of GL lead to OpenGL (1992), a platform-independent API that was Easy to use Close enough to the hardware to get excellent performance Focus on rendering Omitted windowing and input to avoid window system dependencies

5 OpenGL Evolution Controlled by an Architectural Review Board (ARB)
Members include SGI, Microsoft, Nvidia, HP, 3DLabs, IBM,……. Relatively stable (present version 2.0) Evolution reflects new hardware capabilities 3D texture mapping and texture objects Vertex and fragment programs Allows for platform specific features through extensions

6 OpenGL – Open Graphics Library
What it is a s/w interface to graphics h/w mid-level, device-independent, portable graphics subroutine package developed primarily by SGI (Silicon Graphics Inc.) 2D/3D graphics, lower-level primitives (polygons) does not include low-level I/O management basis for higher-level libraries/toolkits

7 OpenGL libraries GL – gl.h – Opengl32.lib
Provides basic commands for graphics drawing GLU (OpenGL Utility Library) – glu.h – glu32.lib Uses GL commands for performing compound graphics like viewing orientation and projection specification polygon tessellations, surface rendering etc. GLUT (OpenGL Utility Toolkit) – glut.h – glut.lib is a window system-independent toolkit for user interaction built on top of OpenGL and WGL (Windows) or GLX (Linux). System-specific OpenGl extensions GLX : for X window system (Linux/Unix) WGL: for Windows 95/98/2000/NT AGL : Apple Macintosh system

8 Software Organization
application program OpenGL Motif widget or similar GLUT GLX, AGL or WGL GLU OpenGL X, Win32, Mac O/S software and/or hardware

9 OpenGL #defines Most constants are defined in the include files gl.h, glu.h and glut.h Note #include <GL/glut.h> should automatically include the others Examples glBegin(GL_POLYGON) glClear(GL_COLOR_BUFFER_BIT) include files also define OpenGL data types: GLfloat, GLdouble,….

10 OpenGL conventions Functions in OpenGL start with gl
Most functions use just gl (e.g., glColor()) Functions starting with glu are utility functions (e.g., gluLookAt()) Note that GLU functions can always be composed entirely from core GL functions Functions starting with glut are from the GLUT library.

11 OpenGL function format
function name dimensions glVertex3f(x,y,z) x,y,z are floats belongs to GL library glVertex3fv(p) p is a pointer to an array

12 Parameter Types b 8-bit integer GLbyte s 16-bit integer GLshort
i 32-bit integer GLint f 32-bit float GLfloat d 64-bit float GLdouble ub 8-bit unsigned int GLubyte us 16-bit unsigned int GLushort ui 32-bit unsigned int GLuint

13 OpenGL conventions Function names indicate argument type and number
Functions ending with f take floats Functions ending with i take ints Functions ending with b take bytes Functions ending with ub take unsigned bytes Functions that end with v take an array. Examples glColor3f() takes 3 floats glColor4fv() takes an array of 4 floats

14 Primitives Primitives: Points, Lines & Polygons
Each object is specified by a set Vertices Grouped together by glBegin & glEnd glBegin(type) glVertex*( ) glEnd( ); type can have 10 possible values

15 Glut Routines Initialization: glutInit() processes (and removes) command­line arguments that may be of interest to glut and the window system and does general initialization of Glut and OpenGL Must be called before any other glut routines Display Mode: The next procedure, glutInitDisplayMode(), performs initializations informing OpenGL how to set up the frame buffer. Display Mode Meaning GLUT_RGB Use RGB colors GLUT_RGBA Use RGB plus alpha (for transparency) GLUT_INDEX Use indexed colors (not recommended) GLUT_DOUBLE Use double buffering (recommended) GLUT_SINGLE Use single buffering (not recommended) GLUT_DEPTH Use depth­buffer (for hidden surface removal.)

16 Glut Routines Window Setup glutInitWindowSize(int width, int height)
glutInitWindowPosition(int x, int y) glutCreateWindow(char* title)

17 Primitive Types Polygon must be: Simple No-holes inside Convex
GL_LINE V0 V1 V2 V3 V5 V4 GL_LINE_STRIP V0 V1 V2 V3 V5 V4 GL_LINE_LOOP V0 V1 V2 V3 V5 V4 Polygon must be: Simple No-holes inside Convex Non-convex Complex P1 P2 GL_POINTS V0 V1 V2 V3 V5 V4 GL_POLYGON V0 V1 V2 V3 V4

18 Primitive Types Order of Vertex rendering 012, 213, 234, 435
GL_TRIANGLE V0 V1 V2 V3 V4 V5 V6 V7 V8 GL_TRIANGLE_STRIP V0 V1 V2 V3 V4 V5 Order of Vertex rendering 012, 213, 234, 435 GL_TRIANGLE_FAN V0 V1 V2 V3 V4 V5 012, 023 , 034, 045 GL_QUAD V0 V1 V2 V3 V4 V5 V6 V7 GL_QUAD_STRIP V0 V1 V2 V3 V4 V5 V6 V7 0132, 2354, 4576

19 An Example void drawParallelogram( GLfloat color[] ) {
glBegin( GL_QUADS ); glColor3fv( color ); glVertex2f( 0.0, 0.0 ); glVertex2f( 1.0, 0.0 ); glVertex2f( 1.5, ); glVertex2f( 0.5, ); glEnd(); }

20 Vertices and Primitives
Points, GL_POINTS Individual points Point size can be altered glPointSize (float size) glBegin(GL_POINTS); glColor3fv( color ); glVertex2f( P0.x, P0.y ); glVertex2f( P1.x, P1.y ); glVertex2f( P2.x, P2.y ); glVertex2f( P3.x, P3.y ); glVertex2f( P4.x, P4.y ); glVertex2f( P5.x, P5.y ); glVertex2f( P6.x, P6.y ); glVertex2f( P7.x, P7.y ); glEnd();

21 Vertices and Primitives
Lines, GL_LINES Pairs of vertices interpreted as individual line segments Can specify line width using: glLineWidth (float width) glBegin(GL_LINES); glColor3fv( color ); glVertex2f( P0.x, P0.y ); glVertex2f( P1.x, P1.y ); glVertex2f( P2.x, P2.y ); glVertex2f( P3.x, P3.y ); glVertex2f( P4.x, P4.y ); glVertex2f( P5.x, P5.y ); glVertex2f( P6.x, P6.y ); glVertex2f( P7.x, P7.y ); glEnd();

22 Vertices and Primitives
Line Strip, GL_LINE_STRIP series of connected line segments

23 Vertices and Primitives
Line Loop, GL_LINE_LOOP Line strip with a segment added between last and first vertices

24 Vertices and Primitives
Polygon , GL_POLYGON boundary of a simple, convex polygon

25 Vertices and Primitives
Triangles , GL_TRIANGLES triples of vertices interpreted as triangles

26 Vertices and Primitives
Triangle Strip , GL_TRIANGLE_STRIP linked strip of triangles v1 v0 v3 v2 v4 v5 v7 v6

27 Vertices and Primitives
Triangle Fan , GL_TRIANGLE_FAN linked fan of triangles v2 v1 v3 v4 v0 v5

28 Vertices and Primitives
Quads , GL_QUADS quadruples of vertices interpreted as four-sided polygons

29 Files Required for GLUT:
Configuring OpenGL in Visual C++ Files Required for GLUT: glut32.dll glut.h glut32.lib

30 Sample Program

31 Closer Look at the main()
includes gl.h #include <GL/glut.h> int main(int argc, char** argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(500,500); glutInitWindowPosition(0,0); glutCreateWindow("simple"); glutDisplayFunc(mydisplay); init(); glutMainLoop(); } define window properties display callback set OpenGL state enter event loop

32 init.c black clear color opaque window fill/draw with white
void init() { glClearColor (0.0, 0.0, 0.0, 1.0); glColor3f(1.0, 1.0, 1.0); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); } black clear color opaque window fill/draw with white viewing volume Set up whatever state you’re going to use Don’t need this much detail unless working in 3D

33 GLUT Callback Functions
Callback function : Routine to call when an event happens Window resize or redraw User input (mouse, keyboard) Animation (render many frames) “Register” callbacks with GLUT glutDisplayFunc( my_display_func ); glutIdleFunc( my_idle_func ); glutKeyboardFunc( my_key_events_func ); glutMouseFunc ( my_mouse_events_func );

34 Rendering Callback Callback function where all our drawing is done
Every GLUT program must have a display callback glutDisplayFunc( my_display_func ); /* this part is in main.c */ void my_display_func (void ) { glClear( GL_COLOR_BUFFER_BIT ); glBegin( GL_TRIANGLE ); glVertex3fv( v[0] ); glVertex3fv( v[1] ); glVertex3fv( v[2] ); glEnd(); glFlush(); }

35 Events in OpenGL Event Example OpenGL Callback Function Keypress
KeyDown KeyUp glutKeyboardFunc Mouse leftButtonDown leftButtonUp glutMouseFunc Motion With mouse press Without glutMotionFunc glutPassiveMotionFunc Window Moving Resizing glutReshapeFunc System Idle Timer glutIdleFunc glutTimerFunc Software What to draw glutDisplayFunc

36 Specify Canvas Color Must always remember to clear canvas before drawing glClearColor( r , g , b , α ) specify the color to clear the canvas to should generally set α to be 0 (i. e., fully transparent) this is a state variable, and can be done only once glClear( GL_ COLOR_ BUFFER_ BIT) actually clears the screen glClear clears such as the depth buffer GL_ DEPTH_ BUFFER_ BIT but we’re not using it right now

37 Redrawing Window void glFlush(void); void glFinish(void);
Forces previously issued OpenGL commands to begin execution It returns before the execution ends. glutSwapBuffers() automatically calls glFlush() For single buffer display function should end with this command void glFinish(void); Forces previously issued OpenGL commands to complete This command doesn’t return until all effects from previous commands are fully realized. void glutPostRedisplay(void); Causes the currently registered display function to be called at the next available opportunity.

38 Initializing GLUT Void glutInit( int argc, char **argv)
initialize glut, process command line arguments such as -geometry, -display etc. void glutInitDisplayMode(unsigned int mode) Mode for later glutCreateWindow() call mode is a bit-wised Ored combination of Either GLUT_RGBA or GLUT_INDEX Either GLUT_SINGLE or GLUT_DOUBLE One or more GLUT_DEPTH, GLUT_STENCIL, GLUT_ACCUM buffers default:RGBA & SINGLE

39 Initializing GLUT void glutInitWindowPosition(int x, int y)
Initial location of window void glutInitWindowSize(int width, int height) Initial size of window int glutCreateWindow(char *name) Called after Init, Displaymode, Position and Size calls Window will not appear until glutMainLoop is called Return value is a unique identifier for the window

40 The command glOrtho() creates an orthographic parallel viewing volume
The command glOrtho() creates an orthographic parallel viewing volume. You specify the corners of the near clipping plane and the distance to the far clipping plane. void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);

41 Each application has its
Event driven approach void glutMainLoop(void); enters the GLUT event processing loop. should be called at most once in a GLUT program. Once called, this routine will never return. It will call as necessary any callbacks that have been registered. While (TRUE) { e=getNextEvent(); switch (e) { case (MOUSE_EVENT): call registered MouseFunc break; case (RESIZE_EVENT): call registered ReshapeFunc } Event Queue Keyboard Callback Mouse Display OS MainLoop Each application has its Own event queue

42 Callback Functions void glutDisplayFunc(void (*func) (void))
Specifies the function that’s called whenever the window is initially opened The content of the window is needed to be redrawn glutPostRedisplay() is explicitly called. void glutReshapeFunc( void (*func)(int width, int height)); The window is resized or moved The function should perform following tasks Call glViewPort(0,0,width, height); // default behavior Redefine projection matrix to match aspect ratio of image & view port

43 Callback Functions void glutKeyboardFunc(
void (* func)(unsigned int key, int x, int y) ); Specifies the function that’s called whenever a key that generates an ASCII character is pressed. The key callback parameter is the generated ASCII value. The x and y callback parameters indicate the location of the mouse when the key was pressed.

44 Callback Functions void glutMouseFunc(
void (* func)(int button, int state, int x, int y)); Specifies the function that’s called whenever a mouse button is pressed or released. button callback parameter is one of GLUT_LEFT_BUTTON GLUT_MIDDLE_BUTTON GLUT_RIGHT_BUTTON state callback parameter is either GLUT_UP GLUT_DOWN The x and y callback parameters indicate the location of the mouse when the event occurred.

45 Animation( Motion = Redraw+Swap )

46 Animation( Motion = Redraw+Swap )

47 Animation( Motion = Redraw+Swap )

48 Transformation in OpenGL
OpenGL uses 3 stacks to maintain transformation matrices: Model & View transformation matrix stack Projection matrix stack Texture matrix stack You can load, push and pop the stack The top most matrix from each stack is applied to all graphics primitive until it is changed M N Graphics Primitives (P) Output N•M•P Model-View Matrix Stack Projection Matrix Stack


50 Translation – 2D x’ = x + dx y’ = y + dy

51 Transformations and OpenGL®
Each time an OpenGL transformation M is called the current MODELVIEW matrix C is altered: glTranslatef(1.5, 0.0, 0.0); glRotatef(45.0, 0.0, 0.0, 1.0); Note: v is any vertex placed in rendering pipeline v’ is the transformed vertex from v.

52 Matrix Operation

53 Thinking About Transformations
There is a World Coordinate System where: All objects are defined Transformations are in World Coordinate space Two Different Views As a Global System Objects moves but coordinates stay the same Think of transformation in reverse order as they appear in code As a Local System Objects moves and coordinates move with it Think of transformation in same order as they appear in code

54 Order of Transformation T•R
glLoadIdentity(); glMultiMatrixf( T); glMultiMatrixf( R); draw_ the_ object( v); v’ = ITRv Global View Rotate Object Then Translate Local View Translate Object Then Rotate Effect is same, but perception is different

55 Order of Transformation R•T
glLoadIdentity(); glMultiMatrixf( R); glMultiMatrixf( T); draw_ the_ object( v); v’ = ITRv Global View Translate Object Then Rotate Local View Rotate Object Then Translate Effect is same, but perception is different

56 OpenGL Programming Guide (3rd Edition)
M. Woo, J. Neider, T. Davis, D. Shreiner Addison-Wesley, 2000

57 Thank You

Download ppt "SUJAN CHOWDHURY Lecturer, CSE, CUET"

Similar presentations

Ads by Google