Inleiding OpenGL

© 2010 Hein Pragt

opengl logoIn de begintijd van de computer werden in grafische applicaties het beeld pixel voor pixel uitgerekend door de CPU en daarna doorgestuurd naar de grafische kaart die ervoor zorg droeg dat een videosignaal naar de monitor gestuurd werd. Dit lost natuurlijk veel rekenkracht en telkens moesten allerlei grafische functies opnieuw geschreven worden. Nu is een eenvoudige lijn niet zo'n probleem maar ingewikkelde 3D transformaties werden al iets moeilijker. OpenGL wat staat voor Open Graphics Library gebruikt een heel andere aanpak voor het genereren van een beeld via een standaard bibliotheek. Naast de CPU kan er ook een grafische processor van de videokaart ingezet worden (de GPU) om het beeld te genereren. In plaats van het beeld punt voor punt aan te leveren, worden kunnen complete objecten, camera posities en licht instellingen aan de GPU geleverd die dit dan afzonderlijk van de CPU kan renderen. De GPU gaat dus zelfstandig het beeld punt voor punt berekenen en dat beeld wordt uiteindelijk naar de monitor gestuurd. Meestal gaat het om het samenwerken van de CPU en de GPU, afhankelijk van de mogelijkheden die beiden hebben.

Toepassingen waar veel gebruikgemaakt wordt van OpenGL zijn simulatoren, CAD systemen, foto en video bewerkingsprogramma's en natuurlijk computerspelletjes waarin soms hele werelden realistisch nagebouwd worden. OpenGL ontstond in 1992 uit het door Silicon Graphics Inc. ontwikkelde IRIS GL en het grote voordeel is dat het niet alleen voor één computersysteem ontwikkeld is maar dat het op vele platformen geïmplementeerd is. Wanneer u dus een spel wilt ontwikkelen dat zowel op Microsoft Windows als linux en de mac moet draaien, kunt u dit met OpenGL oplossen. U moet wel voor elk systeem apart compileren maar de code hoeft niet aangepast te worden. Dit is het enorme voordeel van OpenGL ten opzichte van bijvoorbeeld DirectX van Microsoft.

De OpenGL API is zeer veel gebruikt bij het ontwikkelen van 2D en 3D grafische applicaties en in basis is het de opvolger is van de Silicon Graphics IRIS GL bibliotheek die SGI ontwikkelde voor hun workstations. SGI heeft in OpenGL veel van hun kennis gestoken om een gemakkelijk te gebruiken, eenvoudig te begrijpen, overdraagbare en met netwerk mogelijkheden programmeer interface voor de toekomst te maken. Heel veel hardware en software leveranciers en ontwikkelaars werken mee aan de OpenGL specificatie en het is een gestroomlijnde, supersnelle grafische rendering bibliotheek. Veel grafische acceleratie kaarten en 3D kaarten implementeren die de basis van OpenGL in hun hardware. OpenGL is door zijn ontwerp, platform en besturingssysteem onafhankelijk. Het kan ook omgaan met netwerken dus het is mogelijk om gelaagd te werken en een OpenGL applicatie te splitsen in een server en een client die het eigenlijke renderen van de graphics uit zal voeren. Op de volgende pagina's probeer ik aan de hand van voorbeelden wat uitleg te geven over OpenGL met programmeer voorbeelden. Vriendelijke groet, Hein Pragt


Glut en Freeglut

© 2010 Hein Pragt

Freeglut is een complete open source alternatief voor de OpenGL Utility Toolkit (GLUT) library. GLUT werd oorspronkelijk geschreven door Mark Kilgard om de voorbeeld programma's in de tweede editie van het OpenGL 'RedBook' te ondersteunen. Sindsdien is GLUT veel gebruikt in veel applicaties omdat het simpel, goed beschikbaar en zeer portable (draaiend op meerdere systemen) is.

GLUT en dus ook Freeglut stellen de programmeur in staat om een venster te maken met een OpenGL context voor grafische mogelijkheden maar ook het gebruiken van de muis, toetsenbord en joystick functies. De oorspronkelijke GLUT library leek niet meer onderhouden te worden en de laatste versie 3.7 stamde nog uit 1998 en de licentie was erg beperkend. Freeglut is oorspronkelijk ontwikkeld door Pawel W. Olszta met hulp van Andreas Umbach and Steve Baker. Steve Baker is momenteel de eigenaar en beheerder van Freeglut. Sinds 1999 is de freeglut library een 100% vervanging van het originele GLUT met een paar dingen die vervallen zijn zoals enkele SGI specifieke functies, en zijn een aantal bugs opgelost. Verder zijn er enkel leuke dingen toegevoegd zoals een grotere set voorgedefineerde vormen en objecten die men out of de box kan gebruiken.

De licentie waaronder freeglut verspreid word is de X-Consortium licentie een hele open licentie die geen enkele vorm van auteursrecht en dus absoluut vrij gebruik toestaat ook in closed source producten.

Link: freeglut.sourceforge.net


gl, glu en glut

© 2010 Hein Pragt

Wanneer u OpenGL gaat gebruiken zal het u opvallen dat met over het gl, glu en glut heeft, maar wat is nou het verschil? Voor het programmeren met OpenGL zijn er drie belangrijke libraries:

  • GL is de basis van OpenGL en bevat c.a. 120 functies die allemaal beginnen met de prefix "gl" zoals glColor, glVertex, glTranslate en glRotate.
  • GLU (OpenGL Utility Library) is een library die gebouwd is bovenop de basis GL en deze bevat belangrijke hogere grafische functies zoals gluLookAt en gluPerspective. Hierin kunt u functies vinden voor het mappen van scherm en wereld coördinaten, texture mapping en meer uitgebreide camera functies. Al deze functies beginnen met de prefix "glu".
  • GLUT (OpenGL Utilities Toolkit is een aanvullende module die een interface bied naar een OS (besturingsysteem) voor het maken van vensters, het afhandelen van muis en toetsenbord zoals glutCreatewindow en glutMouseFunc. Al deze functies beginnen met de prefix "glut".


OpenGL en Visual Studio Express 2008 (Deel 1)

© 2010 Hein Pragt

Ik gebruik al jaren de Visual Studio C++ versie van Microsoft (vanaf versie 4.x) en ben nu over op de Visual C++ 2008 Express Edition. Hiermee wilde ik wat gaan programmeren met OpenGL op mijn Windows XP machine (Vista moet ook gewoon werken) en met een paar kleine hindernissen heb ik het allemaa draaiend gekregen. Dit is dan ook het eerste deel van mijn online cursus programmeren in C en OpenGl. De eerste stap is het werkend krijgen van een programmeer omgeving en door het volgen van de volgende stappen kunt u dit voor elkaar krijgen.

OpenGL werkend krijgen met Visual C++


Stap 1, download en installeer Visual C++ 2008 Express Edition

Dit is de gratis C++ compiler met eeb geweldige IDE van Microsoft en een hele mooie en handige ontwikkel omgeving wanneer u applicaties coor Microsoft Windows wilt maken. U kunt Visual C++ 2008 Express Edition vinden en downloaden op de site van Microsoft Visual Studio Express download page, deze versie werkt alleen op Windows XP en hoger.


Stap 2, installeer de Windows SDK for Windows Server 2008 and .NET Framework 3.5

Deze SDK is gelijk aan de Windows Server 2003 SP1 Platform SDK en het bevat ook de OpenGL libraries. U kunt dit ook downloaden op de site van Microsoft Windows SDK for Windows Server 2008 and .NET Framework, het installeren kan enige tijd in beslag nemen.


Stap 3, installeer de GLUT Libraries

Ik gebruik de freeglut implementatie die vrij goed is en die te downloaden is op: freeglut SourceForge page en voor de orignele glut libs GLUT for Win32 dll, lib and header file. Na het downloaden kunt u de bestanden uitpakken en kopieren naar de volgende directories:

  • Kopieer alle .h bestanden naar de \Program Files\Microsoft SDKs\Windows\v6.1\Include\GL folder. Dit moeten de volgende bestanden zijn: glut.h, freeglut.h, freeglut_ext.h, freeglut_std.h.
  • Kopieer alle .lib bestanden naar de \Program Files\Microsoft SDKs\Windows\v6.1\Lib folder. Dit moet de freeglut.lib en de glut32.lib zijn.
  • Kopieer alle .dll bestanden in de \Windows\system32 folder, dit zou de freeglut.dll en de glut32.dll moeten zijn.


Stap 4, maak een nieuw project aan in Visual C++

Maak een nieuw project aan in Visual C++ met een willekeurige naam en stel als template een Win32 Project in, en druk op OK. Druk op Next en ga dan naar de Application Settings en stel Empty Project in en druk weer op OK, het project is nu gereed.

Declareer de dependencies voor uw project.

  • Klik op Project -> [project naam] Properties.
  • Open Configuration Properties.
  • In de Configuration dropdown, selecteer All Configurations.
  • Selecteer Linker -> Input.
  • In het Additional Dependencies veld vult u GlU32.Lib OpenGL32.Lib freeglut.lib glut32.lib in en druk op OK.

Stap 5, maak uw eerste OpenGl bronbestand

Maak een nieuw bronbestand aan in Visual C++ 2008 (c of c++) en knip en plak de volgende code:

#include <GL/glut.h>

void display(void)
{
  /* clear all pixels */
  glClear (GL_COLOR_BUFFER_BIT);
  glColor3f(1.0f, 1.0f, 1.0f); //Defining color (white)
  glBegin(GL_LINE_LOOP);
    glVertex3f(5.0f, 5.0f, 0.0f);
    glVertex3f(25.0f, 5.0f, 0.0f);
    glVertex3f(25.0f, 25.0f, 0.0f);
  glEnd();
  glFlush();
}

void init (void)
{
  /* select clearing color */
  glClearColor (0.5, 0.5, 0.5, 0.0);
  /* initialize viewing values */
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0.0, 30.0, 0.0, 35.0, -1.0, 1.0);
}

int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
  glutInitWindowSize (600, 600);
  glutInitWindowPosition (100, 100);
  glutCreateWindow ("TRIANGLE");
  init ();
  glutDisplayFunc(display);
  glutMainLoop();
  return 0;
}

Druk op F7 om te compileren en daarna op F5 om het uit te voeren, u heeft nu uw eerste OpenGl programma gemaakt.

opengl voorbeeld

OpenGL en Visual Studio Express 2008 Win32 versie (Deel 2)

© 2010 Hein Pragt

Het is ook mogelijk om gebruik te maken van de Microsoft OpenGL implementatie, deze is wel enigszins windows afhankelijk maar de basis van OpgenGL blijft hetzelfde waardoor u wel grafische programma's kunt ontwikkelen die met een paar kleine aanpassingen ook op een ander platform kunnen draaien. Het is aan uzelf om zo weinig mogelijk Win32 code te gebruiken en de Windows code en de OpenGL code zo goed mogelijk te scheiden van elkaar. Dit programma maakt gebruik van de Microsoft OpenGL methodes en zal dan ook een een Microsoft Windows venster draaien. Kopieer het vorige project van Deel 1 en kopieer deze broncode er in. Bestudeer de broncode en ontdek hoe u met Win32 OpenGL kunt programmeren.

// -----------------------------------------------------------------
// Een voorbeeld va een minimaal Win32 en OpenGL programma.
// Maakt gebruik van een MS Windows venster. 
// Het werkt alleen in 16 bit kleuren mode of hoger.
// (c) Hein Pragt 2010 vrij te gebruiken.
// -----------------------------------------------------------------

#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <stdio.h>

// OpenGL code

void display()
{
  glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_TRIANGLES);
    glColor3f(1.0f, 0.0f, 0.0f);
    glVertex2f(0.0,  0.8);
    glColor3f(0.0f, 1.0f, 0.0f);
    glVertex2f(-0.8, -0.8);
    glColor3f(0.0f, 0.0f, 1.0f);
    glVertex2f(0.8, -0.8);
  glEnd();
  glFlush();
}


// Minimale windows interface

#define WIN_CLASS_NAME "MyGraphClass"

// Forward declarations

LONG WINAPI WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
HWND CreateOpenGLWindow(HINSTANCE hInstance,char* title, int x, int y, 
                        int width, int height, BYTE type, DWORD flags);


// Minimal Win32 main function

int APIENTRY WinMain(HINSTANCE hCurrentInst,HINSTANCE hPreviousInst,LPSTR lpszCmd,int nCmdShow)
{
HDC   hDC;	/* device context */
HGLRC hRC;	/* opengl context */
HWND  hWnd;
MSG   msg;
BOOL  quit = FALSE;

  hWnd = CreateOpenGLWindow(hCurrentInst,"Mini OpenGl Demo", 0, 0, 400, 400, PFD_TYPE_RGBA, 0);
  if (hWnd == NULL)
    exit(1);
  hDC = GetDC(hWnd);
  hRC = wglCreateContext(hDC);
  wglMakeCurrent(hDC, hRC);
  ShowWindow(hWnd, nCmdShow);
  // Windows message loop 
  while (!quit) {
    if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
      if (msg.message == WM_QUIT) {
        quit = TRUE;
      } 
      else {
        TranslateMessage( &msg );
        DispatchMessage( &msg );
      }
    }  
  }
  wglMakeCurrent(NULL, NULL);
  ReleaseDC(hWnd,hDC);
  wglDeleteContext(hRC);
  DestroyWindow(hWnd);
  return msg.wParam;
}

HWND CreateOpenGLWindow(HINSTANCE hInstance,char* title, int x, int y, 
                        int width, int height, BYTE type, DWORD flags)
{
int         pf;
HDC         hDC;
HWND        hWnd;
WNDCLASS    wc;
PIXELFORMATDESCRIPTOR pfd;

  wc.style         = CS_OWNDC;
  wc.lpfnWndProc   = (WNDPROC)WindowProc;
  wc.cbClsExtra    = 0;
  wc.cbWndExtra    = 0;
  wc.hInstance     = hInstance;
  wc.hIcon         = LoadIcon(NULL, IDI_WINLOGO);
  wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = NULL;
  wc.lpszMenuName  = NULL;
  wc.lpszClassName = WIN_CLASS_NAME; 

  if (!RegisterClass(&wc)) {
    MessageBox(NULL, "RegisterClass() failed!", "Error", MB_OK);
    return NULL;
  }
  hWnd = CreateWindow(WIN_CLASS_NAME, title, 
    WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 
    x, y, width, height, NULL, NULL, hInstance, NULL);
  if (hWnd == NULL) {
    MessageBox(NULL, "CreateWindow() failed!","Error", MB_OK);
    return NULL;
  }
  hDC = GetDC(hWnd);
  memset(&pfd, 0, sizeof(pfd));
  pfd.nSize        = sizeof(pfd);
  pfd.nVersion     = 1;
  pfd.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | flags;
  pfd.iPixelType   = type;
  pfd.cColorBits   = 32;
  pf = ChoosePixelFormat(hDC, &pfd);
  if (pf == 0) {
    MessageBox(NULL, "ChoosePixelFormat() failed!","Error", MB_OK); 
    return NULL;
  } 
  if (SetPixelFormat(hDC, pf, &pfd) == FALSE) {
    MessageBox(NULL, "SetPixelFormat() failed!","Error", MB_OK);
    return NULL;
  } 
  DescribePixelFormat(hDC, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
  ReleaseDC(hWnd,hDC);
  return hWnd;
}    

// Minimal windows proc handler

LONG WINAPI WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{ 
static PAINTSTRUCT ps;

  switch(uMsg) {
    case WM_PAINT:
      display();
      BeginPaint(hWnd, &ps);
      EndPaint(hWnd, &ps);
      return 0L;
    case WM_SIZE:
      glViewport(0, 0, LOWORD(lParam), HIWORD(lParam));
      PostMessage(hWnd, WM_PAINT, 0, 0);
      return 0L;
    case WM_CHAR:
      switch (wParam) {
      case 27:			/* ESC */
        PostQuitMessage(0);
        break;
      }
      return 0L;
    case WM_CLOSE:
      PostQuitMessage( 0 );
      return 0;
  }
  return DefWindowProc(hWnd, uMsg, wParam, lParam); 
} 

Druk op F7 om te compileren en daarna op F5 om het uit te voeren, u heeft nu uw tweede OpenGl programma gemaakt.

opengl voorbeeld 2

Boeken over OpenGL


OpenGL(r) SuperBible, Sixth Edition, is the definitive programmer's guide, tutorial, and reference for the world's leading 3D API for real-time computer graphics, OpenGL 4.3. The best all-around introduction to OpenGL for developers at all levels of experience, it clearly explains both the newest API and indispensable related concepts. You'll find up-to-date, hands-on guidance for all facets of modern OpenGL development on both desktop and mobile platforms, including transformations, texture mapping, shaders, buffers, geometry management, and much more. Extensively revised, this edition presents many new OpenGL 4.3 features, including compute shaders, texture views, indirect draws, and enhanced API debugging. It has been reorganized to focus more tightly on the API, to cover the entire pipeline earlier, and to help you thoroughly understand the interactions between OpenGL and graphics hardware. Coverage includes * A practical introduction to the essentials of realtime 3D graphics * Core OpenGL 4.3 techniques for rendering, transformations, and texturing * Foundational math for creating interesting 3D graphics with OpenGL * Writing your own shaders, with examples to get you started * Cross-platform OpenGL, including essential platform-specific API initialization material for Linux, OS X, and Windows * Vertex processing, drawing commands, primitive processing, fragments, and framebuffers * Using compute shaders to harness today's graphics cards for more than graphics * Monitoring and controlling the OpenGL graphics pipeline * Advanced rendering: light simulation, artistic and non-photo-realistic rendering, and deferred shading * Modern OpenGL debugging and performance optimization Bonus material and sample code are available from the companion Web site, openglsuperbible. com.


For junior- to graduate-level courses in computer graphics. Assuming no background in computer graphics, this junior- to graduate-level course presents basic principles for the design, use, and understanding of computer graphics systems and applications. The authors, authorities in their field, offer an integrated approach to two-dimensional and three-dimensional graphics topics. A comprehensive explanation of the popular OpenGL programming package, along with C++ programming examples illustrates applications of the various functions in the OpenGL basic library and the related GLU and GLUT packages.


Are you a beginning programmer just getting started in 3D graphics programming? If you're comfortable programming in C++ and have a basic understanding of 3D math concepts, "Beginning OpenGL Game Programming, Second Edition" will get you started programming 3D graphics for games using the OpenGL API. Revised to work with the latest version of OpenGL, OpenGL 3.0, this book is perfect for programmers who are new to game development or new to OpenGL. New skills and concepts are taught using step-by-step instructions, with end-of-chapter exercises for testing and reinforcement. From creating a simple OpenGL application, to applying texture mapping, and even displaying 2D fonts, you'll find complete yet concise coverage of all the newest features of OpenGL as they apply to 3D graphics for game development. And by the end of the book, you'll be able to apply your new-found knowledge of OpenGL to create your very own games.


Last update: 10-03-2011
 Binnen dit thema



 Meer thema's


 Lees hier de privacyverklaring van deze site.

Disclaimer.

Hoewel de heer Hein Pragt de informatie beschikbaar op deze pagina met grote zorg samenstelt, sluit de heer Pragt alle aansprakelijkheid uit met betrekking tot de informatie die, in welke vorm dan ook, via zijn site wordt aangeboden. Het opnemen van een afbeelding of verwijzing is uitsluitend bedoeld als een mogelijke bron van informatie voor de bezoeker en mag op generlei wijze als instemming, goedkeuring of afkeuring worden uitgelegd, noch kunnen daaraan rechten worden ontleend. Op de artikelen van de heer Pragt op deze Internetsite rust auteursrecht. Overname van informatie (tekst en afbeeldingen) is uitsluitend toegestaan na voorafgaande schriftelijke toestemming van de rechthebbende. Voor vragen over copyright en het gebruik van de informatie op deze site kunt u contact opnemen met: (email: mail@heinpragt.com). Dit is mijn