15.3 OpenGl example program

The listing below shows how to implement OpenGL program in MFC.

Pic 9.1 Illustrates the result of program (Here, fog is switched of).

Pic. 9.1 The view of 3-D object in OpenGL program.

Listing 9.1 The example of simple OpenGL program

// App.h: interface for the classes

class CApp : public CWinApp

{public:

BOOL InitInstance();

};

class CMain : public CFrameWnd

{ CPalette *m_pPal;

HGLRC m_hrc;

public:

void MakeImage();

void MakeCheckImage();

void GLInit();

void OnVScroll(UINT SBCode,INT Pos,CScrollBar *SB);

void OnHScroll(UINT SBCode,INT Pos,CScrollBar *SB);

void OnSize(UINT nType, int cx, int cy);

void OnPaint();

BOOL CreateRGBPalette(HDC hDC);

void OnOpenGLFirst();

CMain();

DECLARE_MESSAGE_MAP()

};

// App.cpp: implementation of the classes.

#include <afxwin.h>

#include <afxext.h> // MFC extensions

#include <memory.h>

#include <math.h> // sqrt

#include <mmsystem.h>

#include "gl/gl.h" //OPENGL

#include "gl/glu.h" //OPENGL

#include "gl/glaux.h" //OPENGL

#include "App.h"

#include "resource.h"

#define RANGEMAX 50

int vspos=50;

int hspos=50;

int xmn,ymn,xmx,ymx;

static GLint fogMode;

static GLubyte checkImage[64][64][4];

static GLuint texName;

static GLubyte image[16][16][16][3];

CMain::CMain()

{Create(NULL,"OpenGL Framework Application",WS_OVERLAPPEDWINDOW|WS_VSCROLL|WS_HSCROLL,rectDefault,NULL,MAKEINTRESOURCE(IDR_MENU1));

LoadAccelTable(MAKEINTRESOURCE(IDR_ACCELERATOR1));

SetScrollPos(SB_HORZ,50);

SetScrollPos(SB_VERT,50);

CClientDC dc(this);

// Fill in the Pixel Format Descriptor

PIXELFORMATDESCRIPTOR pfd ;

memset(&pfd,0, sizeof(PIXELFORMATDESCRIPTOR)) ;

pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);

pfd.nVersion = 1 ; // Version number

pfd.dwFlags = PFD_DOUBLEBUFFER | // Use double buffer

PFD_SUPPORT_OPENGL | // Use OpenGL

PFD_DRAW_TO_WINDOW ; // Pixel format is for a window.

pfd.iPixelType = PFD_TYPE_RGBA ;

pfd.cColorBits = 24; // 8-bit color

pfd.cDepthBits = 32 ; // 32-bit depth buffer

pfd.iLayerType = PFD_MAIN_PLANE ; // Layer type

int nPixelFormat = ChoosePixelFormat(dc.m_hDC, &pfd);

BOOL bResult = SetPixelFormat(dc.m_hDC, nPixelFormat, &pfd);

// Create a rendering context.

m_hrc = wglCreateContext(dc.m_hDC);

// Create the palette

CreateRGBPalette(dc.m_hDC) ;

m_pPal = NULL;

}

BOOL CApp::InitInstance()

{m_pMainWnd= new CMain;

m_pMainWnd->ShowWindow(m_nCmdShow);

m_pMainWnd->UpdateWindow();

return TRUE;

}

CApp App;

BEGIN_MESSAGE_MAP(CMain,CFrameWnd)

ON_COMMAND(ID_OPENGL_FIRSTITEM,OnOpenGLFirst)

ON_WM_PAINT()

ON_WM_VSCROLL()

ON_WM_HSCROLL()

ON_WM_SIZE()

END_MESSAGE_MAP()

void CMain::OnOpenGLFirst()

{

// glTranslatef(hspos-50,vspos-50,0.0); // 2D-scrolling

glRotatef(360.0*hspos/100,0,1,0); // 3D-scrolling around y

glRotatef(360.0*vspos/100,1,0,0); // 3D-scrolling around x

auxWireCube(15.0);

auxWireCylinder(3.6,2.4);

auxSolidCylinder(3.2,3.1);

glPopMatrix();

glFlush();

}

BOOL CMain::CreateRGBPalette(HDC hDC)

{ PIXELFORMATDESCRIPTOR pfd;

int n = GetPixelFormat(hDC);

DescribePixelFormat(hDC, n, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

if (!(pfd.dwFlags & PFD_NEED_PALETTE)) return FALSE ;

// allocate a log pal and fill it with the color table info

LOGPALETTE* pPal = (LOGPALETTE*) malloc(sizeof(LOGPALETTE)

+ 256 * sizeof(PALETTEENTRY));

if (!pPal){TRACE("Out of memory for logpal");return FALSE;}

pPal->palNumEntries = 256; // table size

// Create RGB Palette

BOOL bResult = m_pPal->CreatePalette(pPal);

free (pPal);

return bResult;

}

void CMain::OnPaint()

{ CPaintDC pDC(this);

CPalette* ppalOld = NULL;

if (m_pPal){

ppalOld = pDC.SelectPalette(m_pPal, 0);

pDC.RealizePalette();

}

// Make the HGLRC current

BOOL bResult = wglMakeCurrent(pDC.m_hDC, m_hrc);

GLInit(); // Draw

OnOpenGLFirst();

SwapBuffers(pDC.m_hDC) ; //Swap Buffers

if (ppalOld) pDC.SelectPalette(ppalOld, 0); // select old palette if we altered it

wglMakeCurrent(NULL, NULL) ;

}

void CMain::OnSize(UINT nType, int cx, int cy)

{ CClientDC dc(this) ;

// Make the rendering context m_hrc current

BOOL bResult = wglMakeCurrent(dc.m_hDC, m_hrc);

// Set up the mapping of 3-space to screen space

GLdouble gldAspect = (GLdouble) cx/ (GLdouble) cy;

glMatrixMode(GL_PROJECTION);// OutputGlError("MatrixMode") ;

glLoadIdentity();

gluPerspective(30.0, gldAspect, 1.0, 10.0);

glViewport(0, 0, cx, cy);

// No rendering context will be current.

wglMakeCurrent(NULL, NULL);

}

void CMain::OnVScroll(UINT SBCode, INT Pos, CScrollBar *SB)

{char str[255];

switch(SBCode)

{case SB_LINEDOWN: vspos++; break;

case SB_LINEUP: vspos--; break;

case SB_PAGEDOWN: vspos+=5; break;

case SB_PAGEUP: vspos-=5; break;

case SB_THUMBTRACK: vspos=Pos; break;

case SB_THUMBPOSITION: vspos=Pos; break;

}

Invalidate(FALSE);

SetScrollPos(SB_VERT,vspos);

}

void CMain::OnHScroll(UINT SBCode, INT Pos, CScrollBar *SB)

{switch(SBCode)

{case SB_LINERIGHT: hspos++; break;

case SB_LINELEFT: hspos--; break;

case SB_PAGERIGHT: hspos+=5; break;

case SB_PAGELEFT: hspos-=5; break;

case SB_THUMBTRACK: hspos=Pos; break;

case SB_THUMBPOSITION: hspos=Pos; break;

}

Invalidate(FALSE);

SetScrollPos(SB_HORZ,hspos);

}

void CMain::GLInit()

{ GLfloat light_position[]={1.0,1.0,1.0,0.0};

glLightfv(GL_LIGHT0,GL_POSITION,light_position);

static GLdouble marengo[3] = {10.0, 0.0, 0.0 } ;

glEnable(GL_LIGHTING); glEnable(GL_LIGHT0) ;

glEnable(GL_DEPTH_TEST); glClearColor(1.0,1.0,1.0,0.0) ;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE) ;

glEnable(GL_COLOR_MATERIAL) ;

glMatrixMode(GL_MODELVIEW); // OutputGlError("MatrixMode") ;

glLoadIdentity();

glTranslated(0.15, 0.15, -4.5 );

glColor3dv(marengo);

// Fog

glEnable(GL_FOG);

{GLfloat fogColor[4]={1.0,1.0,1.0,0.0};

fogMode=GL_LINEAR;

glFogi(GL_FOG_MODE,fogMode);

glFogfv(GL_FOG_COLOR,fogColor);

glFogf(GL_FOG_DENSITY,0.15);

glFogi(GL_FOG_HINT,GL_DONT_CARE);

glFogi(GL_FOG_START,0.0);

glFogi(GL_FOG_END,5.0);}

glClearColor(0.5,0.5,0.5,1.0) ;

glScalef(0.1,0.1,0.1);

}

void CMain::MakeCheckImage()

{int i,j,c;

for(i=0;i<64;i++){

for(j=0;j<64;j++)

{c=(( ((i&0x8)==0)^((j&0x8))==0))*255;

checkImage[i][j][0]=(GLubyte)c;

checkImage[i][j][1]=(GLubyte)c;

checkImage[i][j][2]=(GLubyte)c;

checkImage[i][j][3]=(GLubyte)255;

}}

}

void CMain::MakeImage()

{int s,t,r;

for(s=0;s<16;s++)

for(t=0;t<16;t++)

for(r=0;r<16;r++)

{image[r][t][s][0]=s*17;

image[r][t][s][1]=s*17;

image[r][t][s][2]=s*17;

}

}