PDA

View Full Version : Help with plataform issue



Aresti
01-16-2009, 04:52 PM
Hello I bought the book Beginning Opengl game programming, is very interesting althought the examples on the book are plataform independent, the main is for windows... I have been reading but i cant figure out how to set the main for the mac.
HELP ME TO RUN THIS CODE ON MY MAC PLEASE


.CPP
Here is the code


#ifdef _WINDOWS
#include <windows.h>
#endif

#include <GLUT/glut.h>
#include <Opengl/gl.h>
#include <math.h>
#include "CGfxOpenGL.h"

CGfxOpenGL::CGfxOpenGL()
{
}

CGfxOpenGL::~CGfxOpenGL()
{
}

bool CGfxOpenGL::Init()
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
return true;
}

bool CGfxOpenGL::Shutdown()
{
return true;
}

void CGfxOpenGL::SetupProjection(int width, int height)
{
if (height == 0) // don't want a divide by zero
{
height = 1;
}

glViewport(0, 0, width, height); // reset the viewport to new dimensions
glMatrixMode(GL_PROJECTION); // set projection matrix current matrix
glLoadIdentity(); // reset projection matrix

// calculate aspect ratio of window
gluPerspective(52.0f,(GLfloat)width/(GLfloat)height,1.0f,1000.0f);

glMatrixMode(GL_MODELVIEW); // set modelview matrix
glLoadIdentity(); // reset modelview matrix

m_windowWidth = width;
m_windowHeight = height;
}

void CGfxOpenGL::Prepare(float dt)
{
}

void CGfxOpenGL::Render()
{
static float angle = 0.0;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear screen and depth buffer
glLoadIdentity();
gluLookAt(0.0, 10.0, 0.1, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

glPolygonMode(GL_FRONT, GL_LINE);
glPushMatrix();
glTranslatef(-4.0f, 0.0f, 0.0f);
glRotatef(angle, 0.0, 0.0, 1.0);
glColor3f(1.0, 0.0, 0.0);
Draw2DSquare();
glPopMatrix();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // reset

glPolygonMode(GL_BACK, GL_POINT);

glPushMatrix();
glTranslatef(-2.0f, 0.0f, 0.0f);
glRotatef(angle, 0.0, 0.0, 1.0);
glColor3f(0.0, 1.0, 0.0);
Draw2DSquare();
glPopMatrix();

glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
glRotatef(angle, 0.0, 0.0, 1.0);
glColor3f(0.0, 0.0, 1.0);
Draw2DSquare();
glPopMatrix();

glPolygonMode(GL_BACK, GL_LINE);

glPushMatrix();
glTranslatef(2.0f, 0.0f, 0.0f);
glRotatef(angle, 0.0, 0.0, 1.0);
glColor3f(1.0, 0.0, 1.0);
Draw2DSquare();
glPopMatrix();

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

glPushMatrix();
glTranslatef(4.0f, 0.0f, 0.0f);
glRotatef(angle, 0.0, 0.0, 1.0);
glColor3f(1.0, 1.0, 0.0);
Draw2DSquare();
glPopMatrix();

glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

angle += 0.2f;
}

void CGfxOpenGL::Draw2DSquare()
{
glBegin(GL_POLYGON);
glVertex3f(-0.5f, 0.0f, 0.0f);
glVertex3f(0.5f, 0.0f, 0.0f);
glVertex3f(0.5f, 0.0f, -1.0f);
glVertex3f(-0.5f, 0.0f,-1.0f);
glEnd();
}



.h

#ifndef __GL_COMPONENT
#define __GL_COMPONENT

#define PI 3.14159
#define TWO_PI PI*2.0
#define HALF_PI PI/2.0

class CGfxOpenGL
{
private:
int m_windowWidth;
int m_windowHeight;

public:
CGfxOpenGL();
virtual ~CGfxOpenGL();

bool Init();
bool Shutdown();

void SetupProjection(int width, int height);

void Prepare(float dt);
void Render();

void Draw2DSquare();
};

#endif

MAIN ON WINDOWS

#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN

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

#include "CGfxOpenGL.h"

bool exiting = false;
long windowWidth = 800;
long windowHeight = 600;
long windowBits = 32;
bool fullscreen = false;
HDC hDC;

CGfxOpenGL *g_glRender = NULL;

void SetupPixelFormat(HDC hDC)
{
int pixelFormat;

PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), // size
1, // version
PFD_SUPPORT_OPENGL | // OpenGL window
PFD_DRAW_TO_WINDOW | // render to window
PFD_DOUBLEBUFFER, // support double-buffering
PFD_TYPE_RGBA, // color type
32, // prefered color depth
0, 0, 0, 0, 0, 0, // color bits (ignored)
0, // no alpha buffer
0, // alpha bits (ignored)
0, // no accumulation buffer
0, 0, 0, 0, // accum bits (ignored)
16, // depth buffer
0, // no stencil buffer
0, // no auxiliary buffers
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0, // no layer, visible, damage masks
};

pixelFormat = ChoosePixelFormat(hDC, &amp;pfd);
SetPixelFormat(hDC, pixelFormat, &amp;pfd);
}

LRESULT CALLBACK MainWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static HDC hDC;
static HGLRC hRC;
int height, width;

// dispatch messages
switch (uMsg)
{
case WM_CREATE: // window creation
hDC = GetDC(hWnd);
SetupPixelFormat(hDC);
//SetupPalette();
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
break;

case WM_DESTROY: // window destroy
case WM_QUIT:
case WM_CLOSE: // windows is closing

// deselect rendering context and delete it
wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);

// send WM_QUIT to message queue
PostQuitMessage(0);
break;

case WM_SIZE:
height = HIWORD(lParam); // retrieve width and height
width = LOWORD(lParam);

g_glRender->SetupProjection(width, height);

break;

case WM_ACTIVATEAPP: // activate app
break;

case WM_PAINT: // paint
PAINTSTRUCT ps;
BeginPaint(hWnd, &amp;ps);
EndPaint(hWnd, &amp;ps);
break;

case WM_LBUTTONDOWN: // left mouse button
break;

case WM_RBUTTONDOWN: // right mouse button
break;

case WM_MOUSEMOVE: // mouse movement
break;

case WM_LBUTTONUP: // left button release
break;

case WM_RBUTTONUP: // right button release
break;

case WM_KEYUP:
break;

case WM_KEYDOWN:
int fwKeys;
LPARAM keyData;
fwKeys = (int)wParam; // virtual-key code
keyData = lParam; // key data

switch(fwKeys)
{
case VK_ESCAPE:
PostQuitMessage(0);
break;
default:
break;
}

break;

default:
break;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX windowClass; // window class
HWND hwnd; // window handle
MSG msg; // message
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT windowRect;

g_glRender = new CGfxOpenGL;

windowRect.left=(long)0; // Set Left Value To 0
windowRect.right=(long)windowWidth; // Set Right Value To Requested Width
windowRect.top=(long)0; // Set Top Value To 0
windowRect.bottom=(long)windowHeight; // Set Bottom Value To Requested Height

// fill out the window class structure
windowClass.cbSize = sizeof(WNDCLASSEX);
windowClass.style = CS_HREDRAW | CS_VREDRAW;
windowClass.lpfnWndProc = MainWindowProc;
windowClass.cbClsExtra = 0;
windowClass.cbWndExtra = 0;
windowClass.hInstance = hInstance;
windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION); // default icon
windowClass.hCursor = LoadCursor(NULL, IDC_ARROW); // default arrow
windowClass.hbrBackground = NULL; // don't need background
windowClass.lpszMenuName = NULL; // no menu
windowClass.lpszClassName = "GLClass";
windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO); // windows logo small icon

// register the windows class
if (!RegisterClassEx(&amp;windowClass))
return 0;

if (fullscreen) // fullscreen?
{
DEVMODE dmScreenSettings; // device mode
memset(&amp;dmScreenSettings,0,sizeof(dmScreenSettings ));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = windowWidth; // screen width
dmScreenSettings.dmPelsHeight = windowHeight; // screen height
dmScreenSettings.dmBitsPerPel = windowBits; // bits per pixel
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWID TH|DM_PELSHEIGHT;

//
if (ChangeDisplaySettings(&amp;dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
// setting display mode failed, switch to windowed
MessageBox(NULL, "Display mode failed", NULL, MB_OK);
fullscreen = FALSE;
}
}

if (fullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
}

AdjustWindowRectEx(&amp;windowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size

// class registered, so now create our window
hwnd = CreateWindowEx(NULL, // extended style
"GLClass", // class name
"BOGLGP - Chapter 2 - OpenGL Application", // app name
dwStyle | WS_CLIPCHILDREN |
WS_CLIPSIBLINGS,
0, 0, // x,y coordinate
windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top, // width, height
NULL, // handle to parent
NULL, // handle to menu
hInstance, // application instance
NULL); // no extra params

hDC = GetDC(hwnd);

// check if window creation failed (hwnd would equal NULL)
if (!hwnd)
return 0;

ShowWindow(hwnd, SW_SHOW); // display the window
UpdateWindow(hwnd); // update the window

g_glRender->Init();

while (!exiting)
{
g_glRender->Prepare(0.0f);
g_glRender->Render();
SwapBuffers(hDC);

while (PeekMessage (&amp;msg, NULL, 0, 0, PM_NOREMOVE))
{
if (!GetMessage (&amp;msg, NULL, 0, 0))
{
exiting = true;
break;
}

TranslateMessage (&amp;msg);
DispatchMessage (&amp;msg);
}
}

delete g_glRender;

if (fullscreen)
{
ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
ShowCursor(TRUE); // Show Mouse Pointer
}

return (int)msg.wParam;
}

scratt
01-20-2009, 03:41 AM
You will probably find that it's not too hard to splice the code into a GLUT main.

Do a search on google and you should find an OpenGL GLUT project template for XCode.

That will actually build and run a small Hello World style program running in GLUT.

Take a look at the main, and with what you are learning it should be both fairly easy, and a good exercise to familiarize yourself with what's going on if you splice the parts of the Windows main into the GLUT main to use the functions you have.