1. OpenGL Programming – Day 1
Young-Min Kang
Tongmyong Univ.

2. Introduction to OpenGL
What is OpenGL?
Software interface to graphics hardware
Open Graphics Library
Free
Platform independent
OpenGL is a library
Set of functions
OpenGL is platform independent
No window management

3. OpenGL vs. DirectX OpenGL DirectX Advantage of OpenGL
Platform independent
DirectX
Optimized for MS-Windows on PC
Advantage of OpenGL
Compatibility
Advantage of DirectX
Optimized Performance

4. OpenGL

5. Basic OpenGL Programming
OpenGL Source Code
#include <WhateverYouNeed.h>
main () {
InitializeWindowPlease();
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0f, 1.0f, 1.0f);
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
glBegin(GL_POLYGON);
glVertex3f(0.25, 0.25, 0.0);
glVertex3f(0.75, 0.25, 0.0);
glVertex3f(0.75, 0.75, 0.0);
glVertex3f(0.25, 0.75, 0.0);
glEnd();
glFlush(); }

6. OpenGL Utilities OpenGL provides GLU GLUT
A small set of geometric primitives
Points, lines, and polygons
GLU
GL Utilities: modeling and viewing manipulation
GLUT
A simple windowing API

7. OpenGL Programming Conventions
OpenGL conventions
OpenGL Commands
Starts with gl- prefix
Suffix conventions
{2|3|4}{s|i|f|d}[v]
2, 3, 4 determines the dimension
s: short / i: integer / f: float / d: double
v: array type
glVertex3f(0.3, 1.0, 0.0);
float vertex[3] = { 0.3, 1.0, 0.0 };
glVertex3fv(vertex);

8. OpenGL Programming Conventions
OpenGL coordinates – Homogeneous coordinate
glVertex2f(1, 2);  (1,2,0,1)
glVertex3f(1, 2, 0);  (1,2,0,1)
glVertex4f(1, 2, 0, 1);  (1,2,0,1)
OpenGL as a state machine
OpenGL is a state machine
States can be turned on or off
Rendering conditions are set and maintained until changed

9. OpenGL Programming Document Resources
Programming guide
Reference manual
What is needed for OpenGL Programming
Headers: Gl.h, glu.h
Libraries: Opengl32.lib, glut32.lib
DLLs: Opengl32.lib, glu32.lib
Optional headers and libraries: Glaux.h, glaux.lib / glut.h, glut32.lib, glut32.dll

10. GLUT download GLUT – The OpenGL Utility Toolkit Why GLUT is needed
Why GLUT is needed
OpenGL has no methods to manage windows
GLUT
Window system independent toolkit for writing OpenGL program
A simple windowing application programming interface
GLUT makes it extremely easy to learn OpenGL programming

11. GLUT installation GLUT GLUT.h GLUT32.lib GLUT32.dll
[$include]/GL/
GLUT32.lib
[$lib]/
GLUT32.dll
C:\Windows\System

12. OpenGL Programming OpenGL programming with GLUT
MS Visual Studio .Net Environments
Where are the OpenGL headers and libraries
Headers
Microsoft Visual Studio .Net 2003\Vc7\PlatformSDK\Include\gl
Gl.h, glu.h, glaux.h
Libraries
Microsoft Visual Studio .Net 2003\Vc7\PlatformSDK\Lib
Opengl32.lib, glu32.lib, glaux.lib
Copy glut files to proper directories
Glut.h  …\Vc7\PlatformSDK\Include\gl
Glut32.lib  …\Vc7\PlatformSDK\Lib
Glut32.dll  C:\Windows\System

13. OpenGL programming
Simple Program
Create win32 console project

14. OpenGL programming Menu: Project  Properties (Linker  input)
Additional Dependency
Opengl32.lib glu32.lib glaux.lib glut32.lib

15. OpenGL programming
Add a source code item

16. OpenGL Programming with GLUT
Headers
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>
Function prototypes
void display(void);
OpenGL display function
void init(void);
OpenGL initialization function

17. OpenGL Programming with GLUT
Main function
int main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGBA);
glutInitWindowSize(250, 250);
glutInitWindowPosition(100,100);
glutCreateWindow("My First OpenGL Program");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0; }

18. OpenGL Programming with GLUT
Initialization Function
void init(void) {
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); }
glClearColor
Determines the color to be used for clearing buffer
glMatrixMode
Determines which matrix would be changed
Projection matrix / Model_View matrix
LoadIdentity
Loads identity matrix
glOrtho
Sets an orthogonal projection matrix

19. OpenGL Programming with GLUT
OpenGL display function
void display(void) {
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_POLYGON);
glVertex3f(0.25, 0.25, 0.0);
glVertex3f(0.75, 0.25, 0.0);
glVertex3f(0.75, 0.75, 0.0);
glVertex3f(0.25, 0.75, 0.0);
glEnd();
glFlush(); }

20. OpenGL and Win32 OpenGL in MS-Windows OpenGL is platform independent
No window management APIs
What is needed
Option 1 – using GLUT
Easy window management
Platform independent
Disadvantage
Console based
Option 2 – using Win32 API
Perfectly integrated into MS-windows environments
Platform dependent
Increased complexity in coding

21. OpenGL and Win32 OpenGL with Win32
Properly include headers and link libraries
Get device context
Win32 API
Set pixel format
Create rendering context
WGL API is needed
Write your own OpenGL code

22. OpenGL and Win32 Headers and libraries Option 1: GLUT Option 2: Win32
Gl.h / glu.h / glut.h
Libraries
Opengl32.lib / glu32.lib / glut32.lib
Option 2: Win32
Glut.h/.lib/.dll are not necessary

23. OpenGL and Win32 Device context (DC) How to get a DC?
An object which both holds information about a device and provides a way to use the device.
Properties
DCs refer to an internal data structure in Windows
DCs are not accessible to applications
programs can only reference device context via a handle
How to get a DC?
Use GetDC(HWND) function in Win32 API
How to release the current DC?
Use ReleaseDC(HWND, HDC) function in Win32 API

24. OpenGL and Win32 Device Context Pixel format Obtaining a DC
HDC hDC = GetDC(hWnd);
Release the DC
ReleaseDC(hDC);
Pixel format
We need to set the pixel format for the DC
Informs the system how we are going to use the DC
Whether Double buffering will be used or not
Whether Z-buffer will be used or not
Which color format will be used …

25. OpenGL and Win32 Pixel format PIXELFORMATDESCRIPTOR pfd;
ZeroMemory( &pfd, sizeof(pfd) );
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_GL |
PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
int iFormat = ChoosePixelFormat(hDC, &pfd);
SetPixelFormat(hDC, iFormat, &pfd);

26. OpenGL and Win32 Render Context How to manipulate GL render context
A bridge to the OpenGL program
HGLRC
Handle of GL render context
How to manipulate GL render context
WGL
Creation of GL render context
HGLRC hRC;
hRC = wglCreateContext(hDC);
Deletion of GL render context
wglDeleteContext(hRC);

27. OpenGL and Win32 Current RC Storing old DC and RC
Multiple instances of GL RC can run simultaneously
Which one is current one?
Making a RC current
wglMakeCurrent(hDC, hRC);
Making a RC not current
wglMakeCurrent(NULL, NULL);
Storing old DC and RC
HDC hOldDC = wglGetCurrentDC();
HDC hOldRC = wglGetCurrentContext(); …
wglMakeCurrent(hOldDC, hOldRC);

28. Win32 Programming
Create an empty Win32 project

29. Win32 Programming Write a simple Win32 program
#include <windows.h>
HWND Win32Init(HINSTANCE hInst,HINSTANCE hPrev,LPSTR szCmdLine, int sw);
void Render(HWND hwnd, HDC hDC);
LONG WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmdLine, int nCmdShow) {
MSG msg;
if (!Win32Init(hInst,hPrev,lpCmdLine, nCmdShow)) return FALSE;
while(true) {
if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT) break;
TranslateMessage(&msg);
DispatchMessage(&msg); }
return msg.wParam;

30. Win32 Programming Win32 Initialization Routine
HWND Win32Init( HINSTANCE hInst, HINSTANCE hPrev,
LPSTR szCmdLine, int nCmdShow);
RegisterClass
CreateWindow

31. Win32 Programming
BOOL Win32Init(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int nCmdShow) {
WNDCLASS WindowClass;
BOOL bSuccess;
char szWndName[] = "Very Simple W32 Application - Young-Min Kang";
char szClsName[] = "VSW32Class";
if (!hPrev) {
WindowClass.hCursor = LoadCursor(0,IDC_ARROW);
WindowClass.hIcon = LoadIcon(NULL,IDI_APPLICATION);
WindowClass.lpszMenuName = NULL;
WindowClass.lpszClassName = szClsName;
WindowClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
WindowClass.hInstance = hInst;
WindowClass.style = CS_BYTEALIGNCLIENT | CS_VREDRAW |
CS_HREDRAW;
WindowClass.lpfnWndProc = (WNDPROC)WndProc;
WindowClass.cbClsExtra = 0;
WindowClass.cbWndExtra = 0;
bSuccess = RegisterClass(&WindowClass);
if(!bSuccess) return NULL; }

32. Win32 Programming HWND hWnd = CreateWindow ( szClsName, // Class name
szWndName // Window Title
/* Window Style */
WS_OVERLAPPED | WS_CAPTION |
WS_SYSMENU | WS_THICKFRAME |
WS_MAXIMIZEBOX | WS_MINIMIZEBOX,
100, 100 // Window Position
512, 512, // Window size
0, // Parent
0, // Class Menu
hInst, // Handle to Window Instance
0 //Additional Parameter );
ShowWindow(hWnd, nCmdShow); // display the window
return hWnd; }

33. Win32 Programming WndProc Window procedure that handles message events
LONG WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam) {
static int x[2], y[2];
HDC hDC = GetDC(hwnd);
switch (msg) {
case WM_CLOSE: DestroyWindow(hwnd);
return FALSE;
case WM_DESTROY: PostQuitMessage(0); break;
case WM_LBUTTONDOWN: x[0] = LOWORD(lParam);
y[0] = HIWORD(lParam); break;
case WM_LBUTTONUP: x[1] = LOWORD(lParam);
y[1] = HIWORD(lParam);
MoveToEx(hDC,x[0],y[0],NULL);
LineTo(hDC,x[1],y[1]);
ReleaseDC(hwnd,hDC); break;
case WM_PAINT: Render(hwnd, hDC); break; }
return DefWindowProc(hwnd,msg,wParam,lParam);

34. OpenGL Programming with Win32
Link libraries

35. OpenGL Programming with Win32
Include headers
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
OpenGL headers must be proceeded by window.h
New functions for OpenGL rendering
void OpenGLDisplay(void);
void OpenGLInit(void);

36. OpenGL Programming with Win32
OpenGL Manager
class COpenGLManager {
public:
HWND m_hWnd;
HDC m_hDC;
HGLRC m_hGLRC;
COpenGLManager() {
m_hWnd = NULL;
m_hDC = NULL;
m_hGLRC = NULL; }
~COpenGLManager() {
StopGL();
void StartGL(HWND hWnd);
void StopGL(void); };

37. OpenGL Programming with Win32
OpenGL enabling method
void COpenGLManager::StartGL(HWND hWnd) {
m_hDC = GetDC(m_hWnd = hWnd);
PIXELFORMATDESCRIPTOR pfd;
ZeroMemory( &pfd, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
int pixelFormat = ChoosePixelFormat(m_hDC, &pfd);
SetPixelFormat(m_hDC, pixelFormat, &pfd);
m_hGLRC = wglCreateContext(m_hDC);
wglMakeCurrent(m_hDC, m_hGLRC); }

38. OpenGL Programming with Win32
OpenGL disabling method
void COpenGLManager:: StopGL(void) {
wglMakeCurrent(NULL, NULL);
if(m_hGLRC)
wglDeleteContext(m_hGLRC);
if(m_hWnd && m_hDC)
ReleaseDC(m_hWnd, m_hDC); }
Declaring an OpenGL Manager instance
COpenGLManager OGLMan;

39. OpenGL Programming with Win32
Insert OpenGL-related codes
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmdLine, int nCmdShow) {
MSG msg;
HWND hWnd;
if (! (hWnd = Win32Init(hInst,hPrev,lpCmdLine, nCmdShow)))
return FALSE;
OGLMan.StartGL(hWnd);
OpenGLInit();
while(true) {
if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT) break;
TranslateMessage(&msg);
DispatchMessage(&msg); }
Render(OGLMan.m_hWnd, OGLMan.m_hDC);
OGLMan.StopGL();
return msg.wParam;

40. OpenGL Programming with Win32
Modify the render function
void Render(HWND hwnd, HDC hDC) {
OpenGLDisplay();
SwapBuffers(hDC); }
Modify the window procedure
LONG WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam) {
HDC hDC = GetDC(hwnd);
switch (msg) {
case WM_CLOSE:
OGLMan.StopGL();
DestroyWindow(hwnd);
return FALSE;
case WM_DESTROY:
PostQuitMessage(0);
break;
return DefWindowProc(hwnd,msg,wParam,lParam);

41. OpenGL Programming with Win32
OpenGL codes
void OpenGLDisplay(void) {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_POLYGON);
glVertex3f(-0.75, -0.75, 0.0);
glVertex3f( 0.75, -0.75, 0.0);
glVertex3f( 0.75, 0.75, 0.0);
glVertex3f(-0.75, 0.75, 0.0);
glEnd(); }
void OpenGLInit(void) {
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);