Sign in to follow this  
b1gjo3

OpenGL window coordinates

Recommended Posts

Im having trouble setting up the coordinate system in my gl window, it seems that my call to glOrtho completely ignores my xmin/xmax and ymin/ymax variables note* that my glwindow.hpp class doesnt call any opengl functions
#include <windows.h>
#include <math.h>
#include "GLWindow.hpp"

const int WIDTH = 800;
const int HEIGHT = 600;

typedef float (*function)(float, float);
typedef void (*normal) (float, float, float, float*);

float f1(float x, float z);
float f2(float x, float z);
void normal1(float x, float y, float z, float* norm);
void normal2(float x, float y, float z, float* norm);

function drawFuncs[2] = {&f1, &f2};
normal normFuncs[2] = {&normal1, &normal2};
int curFIndex = 0;

int drawMethods[3] = {GL_LINE_STRIP, GL_POLYGON, GL_POINTS};
int curDrawIndex = 0;

float theta = 0;
float xmin=-2, xmax=2, ymin=-2,ymax=2,zmin=-2,zmax=2;
int n = 20, m = 20;

void Resize(int w, int h)
{
	//set the viewing area
	glViewport(0, 0, w, h);

	glMatrixMode(GL_PROJECTION);						// Select The Projection Matrix
	glLoadIdentity();									// Reset The Projection Matrix
	glOrtho(xmin, xmax, ymin, ymax, zmin, zmax);
	gluPerspective(45,(GLfloat)w/(GLfloat)h,0.1f,100.0f);

	// Calculate The Aspect Ratio Of The Window
	glMatrixMode(GL_MODELVIEW);							// Select The Modelview Matrix
	glLoadIdentity();
}

void InitGL()
{
	GLfloat mat_specular[] = {0, 1, 0, 0};
	GLfloat mat_diffuse[] = {1, 1, 1, 0};
	GLfloat mat_ambient[] = {1, 1, 1, 0};
	GLfloat shininess[] = {2};
	
	GLfloat light_specular[] = {0, 1, 0, 1};
	GLfloat light_diffuse[] = {1, .9, .9, 0};
	GLfloat light_ambient[] = {.1, .1, .1, 0};
	GLfloat light_position[] = {-20, 4, 0, 0};

	glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
	glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
	glLightfv(GL_LIGHT0, GL_POSITION, light_position);

	glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
	glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
	glMaterialfv(GL_FRONT, GL_SHININESS, shininess);

	glShadeModel(GL_SMOOTH);
	float lmodel_ambient[] = {.4,.4,.4,.4};
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);

	glEnable(GL_DEPTH_TEST);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glClearColor(0,0,0,0);
	glColor3f(0,0,0);
}

//function 1
float f1(float x, float z)
{
	return exp(-x*x-z*z);
}


//norm
void normal1(float x, float y, float z, float* norm)
{
	norm[0] = 2*x*exp(-x*x-z*z);
	norm[1] = 1;
	norm[2] = 2*z*exp(-x*x-z*z);
	float d = norm[0]*norm[0]+norm[1]*norm[1]+norm[2]*norm[2];
	if (d>0)
	{
		for (int k = 0; k < 3; k++)
			norm[k]/=d;
	}
}

//function 2
float f2(float x, float z)
{
	return z*cos(x);
}

//norm 2
void normal2(float x, float y, float z, float* norm)
{
	norm[0] = z*sin(x);
	norm[1] = 1;
	norm[2] = -1*cos(x);
	float d = norm[0]*norm[0]+norm[1]*norm[1]+norm[2]*norm[2];
	if (d>0)
	{
		for (int k = 0; k < 3; k++)
			norm[k]/=d;
	}
}

void DisplayFunc()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glRotatef(20,1,0,0);
	glTranslatef(0,0,-1);
	

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glRotatef(20,1,0,0);
	glRotatef(theta,0,1,0);

	float norm[3];
	double xgap=(xmax-xmin)/n;
	double zgap=(zmax-zmin)/m;

	//float y = 0;

	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			glBegin(drawMethods[curDrawIndex]);
			float x = xmin+i*xgap;
			float z = zmin+j*zgap;
			float y = drawFuncs[curFIndex](x,z);
			glVertex3f(x,y,z);
			normFuncs[curFIndex](x,y,z,norm);
			glNormal3fv(norm);

			 x = xmin+i*xgap;
			 z = zmin+(j+1)*zgap;
			 y = drawFuncs[curFIndex](x,z);
			glVertex3f(x,y,z);
			normFuncs[curFIndex](x,y,z,norm);
			glNormal3fv(norm);

			 x = xmin+(i+1)*xgap;
			 z = zmin+(j+1)*zgap;
			 y = drawFuncs[curFIndex](x,z);
			glVertex3f(x,y,z);
			normFuncs[curFIndex](x,y,z,norm);
			glNormal3fv(norm);
			glEnd();

			glBegin(drawMethods[curDrawIndex]);
			 x = xmin+(i+1)*xgap;
			 z = zmin+j*zgap;
			 y = drawFuncs[curFIndex](x,z);
			glVertex3f(x,y,z);
			normFuncs[curFIndex](x,y,z,norm);
			glNormal3fv(norm);

			 x = xmin+i*xgap;
			 z = zmin+j*zgap;
			 y = drawFuncs[curFIndex](x,z);
			glVertex3f(x,y,z);
			normFuncs[curFIndex](x,y,z,norm);
			glNormal3fv(norm);

			 x = xmin+(i+1)*xgap;
			 z = zmin+(j+1)*zgap;
			 y = drawFuncs[curFIndex](x,z);
			glVertex3f(x,y,z);
			normFuncs[curFIndex](x,y,z,norm);
			glNormal3fv(norm);
			glEnd();
		}
	}
}

void Keyboard(bool* GL_KEYS, bool isDown)
{
	if (GL_KEYS[97])
	{
		m += 5; n+= 5;
	}
	if (GL_KEYS[int('s')])
	{
		m -= 5; n-= 5;
	}
	if (GL_KEYS[int('d')])
	{
		curDrawIndex += 1;
		if (curDrawIndex > 2)
			curDrawIndex = 0;
	}
	if (GL_KEYS[int('f')])
	{
		curFIndex += 1;
		if (curFIndex > 1)
		curFIndex = 0;
	}
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	bool ret = false;

	//start the gl window
	GLWindow myWindow("Function Stuff", WIDTH, HEIGHT);
	myWindow.glInitFunc(InitGL);
	myWindow.glResizeFunc(Resize);
	myWindow.glKeyboard(Keyboard);
	myWindow.glDisplayFunc(DisplayFunc);

	//fulscreen?
	if (myWindow.MsgBox("Do You Want To Run Fullscreen?", "Fullscreen", MB_YESNO | MB_ICONQUESTION) == IDNO)
		ret = myWindow.glStart(false, 32);
	else
		ret = myWindow.glStart(true, 32);

	//if the window failed, close the program
	if (!ret)
	{
		myWindow.MsgBox("Failed to start opengl", "Error", MB_OK | MB_ICONEXCLAMATION);
		return -1;
	}

	ShowCursor(TRUE);

	MSG msg = {0};

	//process window messages
	while (WM_QUIT != msg.message)
	{
		while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) == TRUE)
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}

		//wait until all window messages are processed before drawing scene
		myWindow.glDrawScene();

		theta += 0.1;
		if (theta >360)
			theta = 0;
	}

	return (int)msg.wParam;
}

Share this post


Link to post
Share on other sites
You are calling both glOrth() and gluPerspective() in your Resize(). glOrtho() is to create a orthographic(parallel) viewing frustum, and gluPerspective() is to create a perspective viewing frustum.

Please comment out gluPerspective() call.

Share this post


Link to post
Share on other sites
Ok it is commented out, but i still get the same results.

if you want to try and compiling and testing on your machine here are my window wrapper classes

window.hpp

/***********************************************************************
File: Window.hpp

Copyright (C) 2008 Jacob Bills

//$---------------------------------------------------------------------
A wrapper class for a Window. Can handle Multi-Byte char sets, and
Unicode which is really convienient.

Last Modified: September 29, 2008
Version: v1.0
//*********************************************************************/


#ifndef WINDOW_HPP
#define WINDOW_HPP

#ifndef _WINDOWS_
#include <windows.h>
#endif

#include <string>

/**************************************************************************
Inputs- pointer to a charArray
Outputs- the length of the charArray
**************************************************************************/

int charlen(const char* theCharArray)
{
if (theCharArray == NULL)
return 0;

int x;
for (x = 0; theCharArray[x] != 0; ++x){}
return x;
}

/**************************************************************************
Inputs- pointer to a wideCharArray
Outputs- the length of the wideCharArray
**************************************************************************/

int widelen(const wchar_t* theWideArray)
{
if (theWideArray == NULL)
return 0;

int x;
for (x = 0; theWideArray[x] != 0; ++x){}
return x;
}

/**************************************************************************
Inputs- pointer to a charArray
Outputs- the corresponding wide char array
*note* user is responsible for clearing up memory from this call
**************************************************************************/

wchar_t* ConvertCharToWide(const char* charArray)
{
int len = charlen(charArray)+1;
wchar_t* ret = new wchar_t[len];
MultiByteToWideChar(CP_ACP, NULL, charArray, -1, ret, len);
return ret;
}

/**************************************************************************
Inputs- pointer to a wide char array
Outputs- the corresponding char array
*note* user is responsible for clearing up memory from this call
**************************************************************************/

char* ConvertWideToChar(const wchar_t* wideArray)
{
int len = widelen(wideArray)+1;
char* ret = new char[len];
WideCharToMultiByte(CP_ACP, NULL, wideArray, -1, ret, len, NULL, NULL);
return ret;
}

/**************************************************************************
Inputs- integer
Outputs- the corresponding char array
*note* user is responsible for clearing up memory from this call
**************************************************************************/

char* ConvertIntToChar(int number)
{
char* ch = new char[10];
_itoa_s(number, ch, 10, 10);
return ch;
}

class Window
{
public:
Window();

#ifdef _MBCS
Window(LPCSTR title, int width = 320, int height = 200);
const LPCSTR GetTitle()const;
#endif

#ifdef _UNICODE
Window(const char* title, int width = 320, int height = 200);
const wchar_t* GetTitle()const;
#endif

int MsgBox(const char* message, const char* caption, UINT uType = NULL);
int MsgBox(const int number, const char* caption, UINT uType = NULL);

void SetupWndClass(HICON icon = NULL, HICON smIcon = NULL, HCURSOR cursor = NULL, UINT classStyle = CS_HREDRAW | CS_VREDRAW, int cbsClsExtra = 0, int cbWndExtra = 0, HBRUSH brush = CreateSolidBrush(RGB(240,240,240)), LPCSTR menuName =NULL);

~Window();
const HWND& GetHWND()const;
const HINSTANCE& GetINST()const;

int GetWidth()const {return myWidth;}
int GetHeight()const {return myHeight;}

//these functions should be called before InitWindow
void SetBGColor(int r = 210, int g = 210, int b = 210);
void SetIconBig(HICON icon = NULL);
void SetIconSmall(HICON icon = NULL);
void SetCursor(HCURSOR cursor = NULL);
void SetEnabled(BOOL val = TRUE);
void SetPosition(int x = 0, int y = 0);
void SetMaxButton(BOOL val = true);
void SetMinButton(BOOL val = true);
void SetWidth(int width);
void SetHeight(int height);
void SetStyle(int cStyle = CS_HREDRAW | CS_VREDRAW);
void SetWindowStyle(DWORD style = WS_OVERLAPPEDWINDOW);
void SetWindowExStyle(DWORD style = 0);
void SetVisible(BOOL val = true);

bool InitSimpleWindow(bool fullscreen = false, int bits = 16);
bool InitWindow(bool fullscreen = false, int bits = 16);

char* OpenFileDialog(OPENFILENAME& ofn)const;
char* OpenFileDialog()const;
void DefOpenFileName(OPENFILENAME& ofn)const;

virtual LRESULT WndProc(UINT message, WPARAM wParam, LPARAM lParam);
static LRESULT CALLBACK StaticProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
protected:
HWND myHwnd;
bool myFullscreen;
int myBits;
private:
void SetDefaults();

DWORD myWinStyle, myWinExStyle;
BOOL maxButton, minButton, winEnabled;
int myWidth, myHeight;

#ifdef _MBCS
LPCSTR title;
#endif

#ifdef _UNICODE
wchar_t* title;
#endif

HINSTANCE myInst;
WNDCLASSEX myWndClass;
};

Window::Window()
{
#ifdef _MBCS
title = NULL;
#endif

#ifdef _UNICODE
title = new wchar_t[2];
title[0] = ' ';
title[1] = '\0';
#endif

myWidth = 320;
myHeight = 200;
SetDefaults();
}

#ifdef _MBCS
Window::Window(LPCSTR title, int width, int height)
{
this->title = title;
if (width != NULL)
myWidth = width;
if (height != NULL)
myHeight = height;
SetDefaults();
}

const LPCSTR Window::GetTitle()const
{
return title;
}
#endif

#ifdef _UNICODE
Window::Window(const char* title, int width, int height)
{
size_t len = strlen(title);
this->title = new wchar_t[len+1];

for (size_t i = 0; i < len; i++)
this->title[i] = title[i];

this->title[len] = '\0';

if (width != NULL)
myWidth = width;
if (height != NULL)
myHeight = height;
SetDefaults();
}

const wchar_t* Window::GetTitle()const
{
return title;
}
#endif

void Window::SetupWndClass(HICON icon, HICON smIcon, HCURSOR cursor, UINT classStyle, int cbsClsExtra, int cbWndExtra, HBRUSH brush, LPCSTR menuName)
{
myWndClass.style = classStyle; //the class style
myWndClass.cbClsExtra = cbsClsExtra; //extra bytes to allocate for this class
myWndClass.cbWndExtra = cbWndExtra; //extra bytes to allocate for this instance
myWndClass.hIcon = icon; //icon to associate with the app
myWndClass.hCursor = cursor; //the default cursor to use
myWndClass.hbrBackground = brush; //the background color

#ifdef _MBCS
myWndClass.lpszMenuName = menuName; //the resource name for the menu
#endif

#ifdef _UNICODE
myWndClass.lpszMenuName = (LPCWSTR)menuName;
#endif

myWndClass.hIconSm = smIcon; //handle to the small icon
}

int Window::MsgBox(const char* message, const char* caption, UINT uType)
{
#ifdef _MBCS
if (caption == NULL)
caption = title;

return MessageBox(myHwnd, message, caption, uType);
#endif

#ifdef _UNICODE
int ret = 0;
wchar_t* msg = ConvertCharToWide(message);
wchar_t* cap = ConvertCharToWide(caption);
if (caption != NULL)
ret = MessageBox(myHwnd, msg, cap, uType);
else
ret = MessageBox(myHwnd, msg, title, uType);

delete [] msg;
delete [] cap;
return ret;
#endif
}

int Window::MsgBox(const int number, const char* caption, UINT uType)
{
char ch[10];
_itoa_s(number, ch, 10, 10);
return MsgBox(ch, caption);
}

Window::~Window()
{
#ifdef _UNICODE
delete [] title;
title = NULL;
#endif

if (myFullscreen)
{
ChangeDisplaySettings(NULL,0);
}
}

bool Window::InitSimpleWindow(bool fullscreen, int bits)
{
//setup a simple wndclass
SetupWndClass(NULL, NULL, NULL, CS_HREDRAW | CS_VREDRAW, 0, 0, CreateSolidBrush(RGB(244,244,244)), NULL);

return InitWindow(fullscreen, bits);
}

bool Window::InitWindow(bool fullscreen, int bits)
{
#ifdef _MBCS
myWndClass.lpszClassName = (LPCSTR)title; //class name being created
#endif

#ifdef _UNICODE
myWndClass.lpszClassName = (LPCWSTR)title;
#endif

RegisterClassEx(&myWndClass);

//Resize the Window
RECT rect = {0, 0, myWidth, myHeight};
AdjustWindowRect(&rect, myWinStyle, FALSE);

if (fullscreen)
{
DEVMODE dmScreenSettings;
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings)); //clear variable
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = myWidth;
dmScreenSettings.dmPelsHeight = myHeight;
dmScreenSettings.dmBitsPerPel = bits;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
myFullscreen = false;
return false;
}
}

if (!fullscreen)
{
//for placing window in center of screen
RECT cen;
GetWindowRect(GetDesktopWindow(), &cen);

//create the Window from the class above
myHwnd = CreateWindowEx(myWinExStyle, myWndClass.lpszClassName, myWndClass.lpszClassName,
myWinStyle, (cen.right - myWidth) / 2, (cen.bottom - myHeight) / 2,
rect.right - rect.left, rect.bottom - rect.top,
NULL, NULL, this->myInst, this);
}
else
{
//these two styles make it fullscreen
myWinExStyle = WS_EX_APPWINDOW;
myWinStyle = WS_POPUP;

//create the Window from the class above, also is not centered to screen
myHwnd = CreateWindowEx(myWinExStyle, myWndClass.lpszClassName, myWndClass.lpszClassName,
myWinStyle, 0, 0,
rect.right - rect.left, rect.bottom - rect.top,
NULL, NULL, this->myInst, this);
}

if (!myHwnd)
return false;

//display Window on the screen
ShowWindow(myHwnd, SW_SHOW);
UpdateWindow(myHwnd);
myFullscreen = fullscreen;
myBits = bits;

return true;
}

const HWND& Window::GetHWND()const
{
return myHwnd;
}

const HINSTANCE& Window::GetINST()const
{
return myInst;
}

void Window::DefOpenFileName(OPENFILENAME& ofn)const
{
char CurrentDir[MAX_PATH];

#ifdef _MBCS
GetCurrentDirectory( MAX_PATH, CurrentDir );
ofn.lpstrFilter = "All Files\0*.*\0\0";
ofn.lpstrTitle = "Open a file";
ofn.lpstrInitialDir = CurrentDir;
#endif

#ifdef _UNICODE
wchar_t* initDir = ConvertCharToWide(CurrentDir);
GetCurrentDirectory( MAX_PATH, initDir);
ofn.lpstrFilter = L"All Files\0*.*\0\0";
ofn.lpstrTitle = L"Open a file";
ofn.lpstrInitialDir = initDir;
delete [] initDir;
#endif

ofn.lStructSize = sizeof( OPENFILENAME );
ofn.hwndOwner = NULL;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 0;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.nFileOffset = 0;
ofn.nFileExtension = 0;
ofn.lpstrDefExt = NULL;
ofn.lCustData = 0;
ofn.lpfnHook = NULL;
ofn.lpTemplateName = NULL;
ofn.Flags = OFN_EXPLORER | OFN_ALLOWMULTISELECT;
}

char* Window::OpenFileDialog()const
{
OPENFILENAME defOfn;
DefOpenFileName(defOfn);
return OpenFileDialog(defOfn);
}

char* Window::OpenFileDialog(OPENFILENAME& OpenFileName)const
{
#ifdef _MBCS
char szFile[MAX_PATH];
std::string FData("");
#endif

#ifdef _UNICODE
wchar_t szFile[MAX_PATH];
LPWSTR FData;
#endif

szFile[0] = 0;

OpenFileName.lpstrFile = szFile;
OpenFileName.nMaxFile = sizeof( szFile );

if( GetOpenFileName( &OpenFileName ) )
{
#ifdef _MBCS
size_t len = strlen(OpenFileName.lpstrFile);
#endif

#ifdef _UNICODE
char* conv = ConvertWideToChar(szFile);
size_t len = strlen(conv);
#endif

if( OpenFileName.lpstrFile[len + 1] == 0)
{
// If single file was selected.
char* fPath = new char[MAX_PATH];

#ifdef _MBCS
strcpy_s(fPath, MAX_PATH, szFile);
return fPath;
#endif

#ifdef _UNICODE
strcpy_s(fPath, MAX_PATH, conv);
delete [] conv;
return fPath;
#endif
}
else
{
#ifdef _UNICODE
std::string theStr("");
#endif

FData = OpenFileName.lpstrFile;

#ifdef _UNICODE
char* temp = ConvertWideToChar(FData);
theStr = theStr + temp;
delete [] temp;
#endif

OpenFileName.lpstrFile += len + 1;

while(OpenFileName.lpstrFile[0])
{
#ifdef _MBCS
//This will contain the current file name from multiple selection.
FData = FData + "|" + OpenFileName.lpstrFile;

//find next name
len = strlen(OpenFileName.lpstrFile);
#endif

#ifdef _UNICODE
char* temp = ConvertWideToChar(OpenFileName.lpstrFile);
theStr = theStr + "|" + temp;
len = strlen(temp);
delete [] temp;
#endif

OpenFileName.lpstrFile += len + 1;
}

#ifdef _MBCS
char* ret = new char[FData.length() + 1];
strcpy_s(ret, FData.length() + 2, FData.c_str());
ret[FData.length()] = '\0';
#endif

#ifdef _UNICODE
char* ret = new char[theStr.length() + 1];
strcpy_s(ret, theStr.length() + 2, theStr.c_str());
ret[theStr.length()] = '\0';
#endif

return ret;
}
}
return NULL;
}

void Window::SetDefaults()
{
myInst = NULL;
myHwnd = NULL;
SetBGColor();
SetEnabled();
SetMaxButton();
SetMinButton();
SetStyle();
SetWindowStyle();
SetWindowExStyle();
SetupWndClass();
myWndClass.hInstance = myInst;
myWndClass.cbSize = sizeof(WNDCLASSEX);
myWndClass.lpfnWndProc = (WNDPROC)StaticProc;
myFullscreen = false;
}

void Window::SetBGColor(int r, int g, int b)
{
myWndClass.hbrBackground = CreateSolidBrush(RGB(r,g,b));
}

void Window::SetIconBig(HICON icon)
{
myWndClass.hIcon = icon;
}

void Window::SetIconSmall(HICON icon)
{
myWndClass.hIconSm = icon;
}

void Window::SetCursor(HCURSOR cursor)
{
myWndClass.hCursor = cursor;
}

void Window::SetEnabled(BOOL val)
{
winEnabled = val;
EnableWindow(myHwnd, val);
}

void Window::SetPosition(int x, int y)
{
MoveWindow(myHwnd, x, y, myWidth, myHeight, true);
}

void Window::SetMaxButton(BOOL val)
{
maxButton = val;
}

void Window::SetMinButton(BOOL val)
{
minButton = val;
}

void Window::SetWidth(int width)
{
}

void Window::SetHeight(int height)
{
}

void Window::SetStyle(int cStyle)
{
myWndClass.style = cStyle;
}

void Window::SetWindowStyle(DWORD style)
{
myWinStyle = style;
}

void Window::SetWindowExStyle(DWORD style)
{
myWinExStyle = style;
}

void Window::SetVisible(BOOL val)
{
ShowWindow(myHwnd, val);
}

LRESULT CALLBACK Window::StaticProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
Window* pParent;

// Get pointer to window
if(message == WM_CREATE)
{
pParent = (Window*)((LPCREATESTRUCT)lParam)->lpCreateParams;
//shouldnt be used in 64bit programs??? (__int3264) added to get rid of warning
SetWindowLongPtr(hWnd,GWL_USERDATA,(__int3264)(LONG_PTR)pParent);
}
else
{
pParent = (Window*)GetWindowLongPtr(hWnd,GWL_USERDATA);
if(!pParent) return DefWindowProc(hWnd,message,wParam,lParam);
}

//Call the non-static window proc
pParent->myHwnd = hWnd;
return pParent->WndProc(message,wParam,lParam);
}

LRESULT Window::WndProc(UINT message, WPARAM wParam, LPARAM lParam)
{
//check any available messages from the queue
switch (message)
{
case WM_KEYDOWN:
switch(wParam)
{
//check if user hit escape key
case VK_ESCAPE: PostQuitMessage(0);
break;
}
break;

//the user hit the close button
case WM_DESTROY:
PostQuitMessage(0);
break;
}

return DefWindowProc(myHwnd, message, wParam, lParam);
}

#endif



and glwindow.hpp

/***********************************************************************
File: GLWindow.hpp

Copyright (C) 2008 Jacob Bills

//$---------------------------------------------------------------------
This class helps create a window for rendering graphics using the
opengl library. It is an extension of the Window class and can
run in fullscreen and windowed mode

Last Modified: September 29, 2008
Version: v1.0
//*********************************************************************/


#ifndef GL_WINDOW
#define GL_WINDOW

#include "window.hpp"
#include <glut.h>

typedef void (*VOIDFUNC)();
typedef void (*IIFUNC)(int,int);
typedef void (*KFUNC)(bool*, bool);

class GLWindow : public Window
{
public:
GLWindow(const char* title, int width, int height, bool fullscreen = false, int bits = 16);
~GLWindow();

//gl functions setup
void glDisplayFunc(VOIDFUNC ptrFunction) {myDraw = ptrFunction;}
void glInitFunc(VOIDFUNC ptrFunction) {myInit = ptrFunction;}
void glResizeFunc(IIFUNC ptrFunction) {myResize = ptrFunction;}
void glMouseFunc(IIFUNC ptrFunction) {myMouse = ptrFunction;}
void glKeyboard(KFUNC ptrFunction) {myKeyboard = ptrFunction;}

//gl action functions
void glShowCursor(bool show) {ShowCursor(show);}
void glDrawScene() {myDraw(); SwapBuffers(dc);}

//starts the gl window, sets pixel format
bool glStart(bool fullscreen = false, int bits = 16);

//the window procedure function
virtual LRESULT WndProc(UINT message, WPARAM wParam, LPARAM lParam);
private:
//functions
VOIDFUNC myInit;
VOIDFUNC myDraw;
IIFUNC myResize;
IIFUNC myMouse;
KFUNC myKeyboard;

HGLRC hRC;
HDC dc;

bool GL_KEYS[256];

int width, height;
};

GLWindow::GLWindow(const char* title, int width, int height, bool fullscreen, int bits):Window(title, width, height)
{
this->width = width;
this->height = height;
myInit = NULL;
myDraw = NULL;
myResize = NULL;
myMouse = NULL;
myKeyboard = NULL;

for (int i = 0; i < 256; i++)
GL_KEYS[i] = false;
}

GLWindow::~GLWindow()
{
//release rendering context
wglMakeCurrent(NULL,NULL);

//delete context
wglDeleteContext(hRC);

//release our dc
ReleaseDC(myHwnd, dc);

//show cursor
ShowCursor(TRUE);
}

bool GLWindow::glStart(bool fullscreen, int bits)
{
GLuint PixelFormat;

if (myInit == NULL || myResize == NULL)
{
this->MsgBox("You havnt setup the GLWindow class properly yet, make sure you check that your functions passed to the GLWindow class", "Faield to Start GLWindow", MB_OK | MB_ICONEXCLAMATION);
return false;
}

bool ret = Window::InitWindow(fullscreen, bits);

if (!ret)
return false;

static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
bits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};

dc = GetDC(myHwnd);

if (!dc)
{
MsgBox("Failed to get dc of window", "Error", MB_OK | MB_ICONEXCLAMATION);
return false;
}

if (!(PixelFormat = ChoosePixelFormat(dc, &pfd)))
{
MsgBox("Failed to get pixel format", "Error", MB_OK | MB_ICONEXCLAMATION);
return false;
}

if(!SetPixelFormat(dc,PixelFormat,&pfd))
{
MsgBox("Failed to set pixel format", "Error", MB_OK | MB_ICONEXCLAMATION);
return false;
}

//create rendering context
if (!(hRC=wglCreateContext(dc)))
{
MsgBox("Failed to create rendering context", "Error", MB_OK | MB_ICONEXCLAMATION);
return false;
}

if(!wglMakeCurrent(dc,hRC))
{
MsgBox("Failed to apply rendering context", "Error", MB_OK | MB_ICONEXCLAMATION);
return false;
}

ShowCursor(FALSE);

//init gl
myInit();
myResize(width, height);

return true;
}

LRESULT GLWindow::WndProc(UINT message, WPARAM wParam, LPARAM lParam)
{
//check any available messages from the queue
switch (message)
{
case WM_MOUSEMOVE:
if (myMouse != NULL)
myMouse(LOWORD(lParam), HIWORD(lParam));
break;
case WM_KEYDOWN:
switch(wParam)
{
//check if user hit escape key
case VK_ESCAPE: PostQuitMessage(0); break;
default:
if (wParam == VK_SHIFT)
GL_KEYS[wParam] = true;

if (wParam >=65 && wParam <= 90)
{
if (GL_KEYS[VK_SHIFT] == true)
GL_KEYS[wParam] = true;
else
GL_KEYS[wParam+32] = true;
}
else if (wParam >= 48 && wParam <= 57)
{
if (GL_KEYS[VK_SHIFT] == true)
{
if (wParam == 49) {GL_KEYS[33] = true;}
if (wParam == 50) {GL_KEYS[64] = true;}
if (wParam == 51) {GL_KEYS[35] = true;}
if (wParam == 52) {GL_KEYS[36] = true;}
if (wParam == 53) {GL_KEYS[37] = true;}
if (wParam == 54) {GL_KEYS[94] = true;}
if (wParam == 55) {GL_KEYS[38] = true;}
if (wParam == 56) {GL_KEYS[42] = true;}
if (wParam == 57) {GL_KEYS[40] = true;}
if (wParam == 48) {GL_KEYS[41] = true;}
}
else
GL_KEYS[wParam] = true;
}
else
GL_KEYS[wParam] = true;

if (myKeyboard != NULL)
{
if ( (lParam >> 15) > 32000)
myKeyboard(GL_KEYS, true);
else
myKeyboard(GL_KEYS, false);
}

break;
}
break;

case WM_KEYUP:
if (wParam == VK_SHIFT)
GL_KEYS[wParam] = true;

if (wParam >=65 && wParam <= 90)
{
if (GL_KEYS[VK_SHIFT] == true)
GL_KEYS[wParam] = false;
else
GL_KEYS[wParam+32] = false;
}
else if (wParam >= 48 && wParam <= 57)
{
if (GL_KEYS[VK_SHIFT] == true)
{
if (wParam == 49) {GL_KEYS[33] = false;}
if (wParam == 50) {GL_KEYS[64] = false;}
if (wParam == 51) {GL_KEYS[35] = false;}
if (wParam == 52) {GL_KEYS[36] = false;}
if (wParam == 53) {GL_KEYS[37] = false;}
if (wParam == 54) {GL_KEYS[94] = false;}
if (wParam == 55) {GL_KEYS[38] = false;}
if (wParam == 56) {GL_KEYS[42] = false;}
if (wParam == 57) {GL_KEYS[40] = false;}
if (wParam == 48) {GL_KEYS[41] = false;}
}
else
GL_KEYS[wParam] = false;
}
else
GL_KEYS[wParam] = false;

if (wParam == VK_SHIFT && GL_KEYS[VK_SHIFT])
GL_KEYS[VK_SHIFT] = false;

if (myKeyboard != NULL)
myKeyboard(GL_KEYS, false);

break;

case WM_SIZE:
if (myResize != NULL)
myResize(LOWORD(lParam), HIWORD(lParam));

break;

//the user hit the close button
case WM_DESTROY:
PostQuitMessage(0);
break;
}

return DefWindowProc(myHwnd, message, wParam, lParam);
}

#endif



please keep in mind my wrapper classes are still not perfect and havnt been optimized.

Share this post


Link to post
Share on other sites
That's because you are resetting the projection matrix in the display function:

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glRotatef(20,1,0,0);
glTranslatef(0,0,-1);


Keep in mind that OpenGL is a state machine, i you change state it will stick globally until you change it again. Typically you should set the projection matrix only on program init, and screen resize, unless you need multiple different projections for single frame (lets say 3d perspective scene with overlay 2D ortho HUD). Keep all your camera and scene movements (rotate,translate,..) to modelview matrix.

Share this post


Link to post
Share on other sites
thank you! it worked after i got rid of glPerspective, and
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glRotatef(20,1,0,0);
glTranslatef(0,0,-1);

much appreciation!

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this