LECTURE 02 OPENGL API

Size: px

Start display at page:

Download "LECTURE 02 OPENGL API"

Carmel Heath
5 years ago
Views:

1 COMPUTER GRAPHICS LECTURE 02 OPENGL API Still from Pixar s Inside Out, 2015 IMRAN IHSAN ASSISTANT PROFESSOR

2 EARLY HISTORY OF APIS IFIPS (1973) formed two committees to come up with a standard graphics API Graphical Kernel System (GKS) 2D but contained good workstation model Core Both 2D and 3D GKS adopted as IS0 and later ANSI standard (1980s) GKS not easily extended to 3D (GKS-3D) Far behind hardware development

3 PHIGS AND X Programmers Hierarchical Graphics System (PHIGS) Arose from CAD community Database model with retained graphics (structures) X Window System DEC/MIT effort Client-server architecture with graphics PEX combined the two Not easy to use (all the defects of each) 3

4 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

5 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

6 OPENGL EVOLUTION Originally controlled by an Architectural Review Board (ARB) Members included SGI, Microsoft, Nvidia, HP, 3DLabs, IBM, Now Khronos Group Was relatively stable (through version 2.5) Backward compatible Evolution reflected new hardware capabilities 3D texture mapping and texture objects Vertex and fragment programs Allows platform specific features through extensions 6

7 OPENGL ARCHITECTURE MODERN OPENGL Performance is achieved by using GPU rather than CPU Control GPU through programs called shaders Application s job is to send data to GPU GPU does all rendering 7

8 OPENGL ARCHITECTURE GPU CARDS 8

9 OPENGL 3.1 Totally shader-based No default shaders Each application must provide both a vertex and a fragment shader No immediate mode Few state variables Most 2.5 functions deprecated Backward compatibility not required 9

10 OPENGL OTHER VERSIONS OpenGL ES WebGL Embedded systems Version 1.0 simplified OpenGL 2.1 Version 2.0 simplified OpenGL 3.1 Shader based Javascript implementation of ES 2.0 Supported on newer browsers OpenGL 4.1 and 4.2 Add geometry shaders and tessellator 10

11 WHAT ABOUT DIRECT X? Windows only Advantages Better control of resources Access to high level functionality Disadvantages New versions not backward compatible Windows only Recent advances in shaders are leading to convergence with OpenGL 11

12 OPENGL LIBRARIES OpenGL core library OpenGL32 on Windows GL on most unix/linux systems (libgl.a) OpenGL Utility Library (GLU) Provides functionality in OpenGL core but avoids having to rewrite code Will only work with legacy code Links with window system GLX for X window systems WGL for Windows AGL for Macintosh 12

13 GLUT OPENGL UTILITY TOOLKIT (GLUT) Provides functionality common to all window systems Open a window Get input from mouse and keyboard Menus Event-driven Code is portable but GLUT lacks the functionality of a good toolkit for a specific platform No slide bars 13

14 GRAPHICS LIBRARIES GLUI: GLUT-based user interface library (libglui) Offer controls to OpenGL applications, e.g., buttons, checkboxes, radio buttons, etc. 14

15 FREEGLUT GLUT was created long ago and has been unchanged Amazing that it works with OpenGL 3.1 Some functionality can t work since it requires deprecated functions freeglut updates GLUT Added capabilities Context checking 15

16 GLEW OpenGL Extension Wrangler Library Makes it easy to access OpenGL extensions available on a particular system Avoids having to have specific entry points in Windows code Application needs only to include glew.h and run a glewinit() 16

17 SOFTWARE ORGANIZATION 17

OPENGL IS AN API Application Programmers Interface: a link between low-level: graphics hardware high-level: application program you write OpenGL

18 OPENGL IS AN API Application Programmers Interface: a link between low-level: graphics hardware high-level: application program you write OpenGL ES (for embedded systems): a subset of desktop OpenGL, providing lightweight interface for 2D/3D graphics on mobile and hand-held devices, etc. 18

19 OPENGL FUNCTIONS Primitives Points Line Segments Triangles Attributes Transformations Viewing Modeling Control (GLUT) Input (GLUT) Query 19

20 OPENGL STATE OpenGL is a state machine OpenGL functions are of two types Primitive generating Can cause output if primitive is visible How vertices are processed and appearance of primitive are controlled by the state State changing Transformation functions Attribute functions Under 3.1 most state variables are defined by the application and sent to the shaders 20

21 LACK OF OBJECT ORIENTATION OpenGL is not object oriented so that there are multiple functions for a given logical function gluniform3f gluniform2i gluniform3dv Underlying storage mode is the same Easy to create overloaded functions in C++ but issue is efficiency 21

22 OPENGL FUNCTION FORMAT 22

23 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 glenable(gl_depth_test) glclear(gl_color_buffer_bit) include files also define OpenGL data types: GLfloat, GLdouble,... 23

24 OPENGL WINDOW (VERSION 2.0) INSTALLATION First off you are going to need to download: FreeGLUT GLEW Once you have them both, follow their installation instructions, which are fairly simple. In short, find the lib and include folders for your current Visual Studio installation (for VC, not for VC#), and put the required files in each folder. Then find your System32 or SysWOW64 folder, and put the required dll files in them. 24

25 VISUAL STUDIO PROJECT CONFIGURATION First thing to do would be to place all the files in their correct directories. glut.h: C:\Program Files (x86)\microsoft Visual Studio 10.0\VC\include\GL\ glut32.lib: C:\Program Files (x86)\microsoft Visual Studio 10.0\VC\lib\ glut32.dll: C:\Windows\System32\ For 64-bit machines, you will want to do this. glut32.dll: C:\Windows\SysWOW64\ To use the sglew, you need to copy the headers and libraries into their destination directories. On Windows this typically boils down to copying: bin/glew32.dll to %SystemRoot%/system32 lib/glew32.lib to {VC Root}/Lib include/gl/glew.h to {VC Root}/Include/GL include/gl/wglew.h to {VC Root}/Include/GL 25

26 INSTALLING GLUT ON VISUAL STUDIO Under Visual C++, select Empty Project. 2. Go to Project -> Properties. Select Linker -> Input then add the following to the Additional Dependencies field: opengl32.lib glu32.lib glut32.lib NOTE: NOTE: If you will be also installing GLEW be sure to place, #include <GL/glew.h>, before the include for GLUT. Also place glewinit(); after your glutcreatewindow. This is where things differ a bit between Visual Studio 2010 and the previous versions. In the previous versions we would just add into the VC++ Directories, but they have since done away with this and replaced it with Property Sheets. 26

27 INSTALLING GLUT ON VISUAL STUDIO Go to View -> Property Manager. 4. Right click and Add New Project Property Sheet. I just named my new Project Property Sheet as GLUT and so I will be referring to our Property Sheet as GLUT. 5. You should now see GLUT under Microsoft.Cpp.Win32.user in both the Debug and Release section of the Property Manager. 6. Right-click GLUT select Properties, then select VC++ Directories. 7. Select Include Directories and choose Edit 8. Either enter this directory C:\Program Files (x86)\microsoft Visual Studio 10.0\VC\include\GL or browse to it. 9. Everything should work now! Please leave a comment if it worked or ran across any problems. 27

28 CODING And finally, let s get on to some coding. First, start a new C++ file in your project, you can call it whatever you like, but I always like to call my first file main.cpp, because I m just so original :) Inside your cpp file, you will want to first of all, include the header files for GLUT/FreeGLUT and OpenGL. Which after you have entered them, will look something like: #include // Include the GLEW header file #include // Include the GLUT header file And then create your standard main method, something like: int main (void) { } If this compiles, then you have your header files setup correctly. Congratulations! 28

29 GLUT Now it s time to actually start using GLUT and get a window appearing. The first thing we will want to do is redefine our main method, this is because all of our GLUT calls will be done in this method, and these parameters are required by GLUT. Change the declaration of your main method to: int main (int argc, char **argv) { } The parameters argc and argv allow us to add command line arguments, and are required when we initialize GLUT. 29

30 GLUT INITIALIZE So now we initialize GLUT, which is done like so: glutinit(&argc, argv); // Initialize GLUT After we have initialized GLUT, we need to tell it how we want to setup our window. Here we tell GLUT if we want one or two buffers, if we want an alpha channel, if we want depth and stencil buffers, etc. Let s start off simple, and go with the most basic, GLUT_SINGLE which will give us a single buffered window. glutinitdisplaymode (GLUT_SINGLE); // Set up a basic display buffer (only single buffered for now) 30

31 GLUT INITIALIZE Next, we need to set the size and the position on the screen for our GLUT window: glutinitwindowsize (500, 500); // Set the width and height of the window glutinitwindowposition (100, 100); // Set the position of the window And finally, we create our window and give it a title/caption: glutcreatewindow ( Your first OpenGL Window ); // Set the title for the window 31

32 GLUT This is going good, we now have a window of the size and position we want, and this should compile and display if you would like to test it (I know I did!). Testing your code often is a great habit to get into. I have known a lot of people to write a lot of code, compile it, and then not know where to start debugging. Even if all you are doing is checking for compilation errors, it s good to fix these up early. Once you run this, you will have a window appear with a console window behind it, and it will then disappear as your application would have run out of code and have exited. So now we have a couple more methods to set up before GLUT opens a window, and then keeps it open. The first of these things, is we want to tell GLUT what method will store our code for drawing, so that GLUT can then call on it when needed. As per a lot of OpenGL tutorials, I am going to use a method called display, as I have picked up the habit. You can call this anything you like, but it has to be declared like such: void display (void) { } 32

33 GLUT Once we have a method we can use to do our drawing, we need to actually tell GLUT to use this method. To do so, we make a call to glutdisplayfunc() and pass in our display method, this is done inside of our main method after we create our window. glutdisplayfunc(display); Now that GLUT knows what method to use for drawing, all we have to do is tell GLUT to enter its Main loop. This is just a giant loop that continues forever, whilst calling the display, idle, keyboard, mouse and any other call back methods. So in code, it looks theoretically something like: while (running) { display(); } And while this loop is going, so is your application. So to start it, call: glutmainloop(); If you choose to run this, your window will stay open, but your window doesn t have any OpenGL calls in it yet. So to show that OpenGL is working, lets fill in a basic display method. 33

34 GLUT To do this, we will first set the colour we want the window background to be. We do this with the call to glclearcolor, which takes in 4 float parameters, each one referring to a colour, and in the other (red, green, blue, alpha). So add this line to your display function, and we should get a nice red background: glclearcolor(1.f, 0.f, 0.f, 1.f); // Clear the background of our window to red Now that we have the background colour set, let s get into the habit of some cleaning up in OpenGL. Every time this display method is called in our loop, it adds on to what is currently stored in OpenGL s giant state machine. So we need to clean this out, and reset it. We will reset the colour buffer, so that we get our red background every time, and we will load the identity matrix, so all our drawing starts at the same location as the previous time this method was called: 34

35 GLUT glclear (GL_COLOR_BUFFER_BIT); //Clear the colour buffer (more buffers later on) glloadidentity(); // Load the Identity Matrix to reset our drawing locations And finally to top it all off, after we have drawn everything we want, we need a way to tell OpenGL to draw everything we have currently told it. In a single buffered window, we want to just do a straight flush from OpenGL to the window, and we can do this with: glflush(); // Flush the OpenGL buffers to the window And that is it, if everything has worked along the way, you should now have a window that shows up with an OpenGL context, and displays a red background. 35

36 MY FIRST PROGRAM COMPLETE CODE #include <GL/glew.h> // Include the GLEW header file #include <GL/glut.h> // Include the GLUT header file void display (void) { glclearcolor(1.0f, 0.0f, 0.0f, 1.0f); // Clear the background of our window to red glclear(gl_color_buffer_bit); //Clear the colour buffer (more buffers later on) glloadidentity(); // Load the Identity Matrix to reset our drawing locations glflush(); // Flush the OpenGL buffers to the window } 36

37 MY FIRST PROGRAM COMPLETE CODE int main (int argc, char **argv) { glutinit(&argc, argv); // Initialize GLUT glutinitdisplaymode (GLUT_SINGLE); // Set up a basic display buffer (only single buffered for now) glutinitwindowsize (500, 500); // Set the width and height of the window glutinitwindowposition (100, 100); // Set the position of the window glutcreatewindow ("Your first OpenGL Window"); // Set the title for the window glutdisplayfunc(display); // Tell GLUT to use the method "display" for rendering glutmainloop(); // Enter GLUT's main loop } 37

Programming with OpenGL Part 1: Background

Programming with OpenGL Part 1: Background Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts University of New Mexico 1 Objectives Development of the OpenGL API