Sign in to follow this  
b1gjo3

OpenGL window coordinates

Recommended Posts

b1gjo3    213
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
songho    268
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
b1gjo3    213
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
snoutmate    362
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
b1gjo3    213
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  

  • Similar Content

    • By markshaw001
      Hi i am new to this forum  i wanted to ask for help from all of you i want to generate real time terrain using a 32 bit heightmap i am good at c++ and have started learning Opengl as i am very interested in making landscapes in opengl i have looked around the internet for help about this topic but i am not getting the hang of the concepts and what they are doing can some here suggests me some good resources for making terrain engine please for example like tutorials,books etc so that i can understand the whole concept of terrain generation.
       
    • By KarimIO
      Hey guys. I'm trying to get my application to work on my Nvidia GTX 970 desktop. It currently works on my Intel HD 3000 laptop, but on the desktop, every bind textures specifically from framebuffers, I get half a second of lag. This is done 4 times as I have three RGBA textures and one depth 32F buffer. I tried to use debugging software for the first time - RenderDoc only shows SwapBuffers() and no OGL calls, while Nvidia Nsight crashes upon execution, so neither are helpful. Without binding it runs regularly. This does not happen with non-framebuffer binds.
      GLFramebuffer::GLFramebuffer(FramebufferCreateInfo createInfo) { glGenFramebuffers(1, &fbo); glBindFramebuffer(GL_FRAMEBUFFER, fbo); textures = new GLuint[createInfo.numColorTargets]; glGenTextures(createInfo.numColorTargets, textures); GLenum *DrawBuffers = new GLenum[createInfo.numColorTargets]; for (uint32_t i = 0; i < createInfo.numColorTargets; i++) { glBindTexture(GL_TEXTURE_2D, textures[i]); GLint internalFormat; GLenum format; TranslateFormats(createInfo.colorFormats[i], format, internalFormat); // returns GL_RGBA and GL_RGBA glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, createInfo.width, createInfo.height, 0, format, GL_FLOAT, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); DrawBuffers[i] = GL_COLOR_ATTACHMENT0 + i; glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, textures[i], 0); } if (createInfo.depthFormat != FORMAT_DEPTH_NONE) { GLenum depthFormat; switch (createInfo.depthFormat) { case FORMAT_DEPTH_16: depthFormat = GL_DEPTH_COMPONENT16; break; case FORMAT_DEPTH_24: depthFormat = GL_DEPTH_COMPONENT24; break; case FORMAT_DEPTH_32: depthFormat = GL_DEPTH_COMPONENT32; break; case FORMAT_DEPTH_24_STENCIL_8: depthFormat = GL_DEPTH24_STENCIL8; break; case FORMAT_DEPTH_32_STENCIL_8: depthFormat = GL_DEPTH32F_STENCIL8; break; } glGenTextures(1, &depthrenderbuffer); glBindTexture(GL_TEXTURE_2D, depthrenderbuffer); glTexImage2D(GL_TEXTURE_2D, 0, depthFormat, createInfo.width, createInfo.height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthrenderbuffer, 0); } if (createInfo.numColorTargets > 0) glDrawBuffers(createInfo.numColorTargets, DrawBuffers); else glDrawBuffer(GL_NONE); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) std::cout << "Framebuffer Incomplete\n"; glBindFramebuffer(GL_FRAMEBUFFER, 0); width = createInfo.width; height = createInfo.height; } // ... // FBO Creation FramebufferCreateInfo gbufferCI; gbufferCI.colorFormats = gbufferCFs.data(); gbufferCI.depthFormat = FORMAT_DEPTH_32; gbufferCI.numColorTargets = gbufferCFs.size(); gbufferCI.width = engine.settings.resolutionX; gbufferCI.height = engine.settings.resolutionY; gbufferCI.renderPass = nullptr; gbuffer = graphicsWrapper->CreateFramebuffer(gbufferCI); // Bind glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); // Draw here... // Bind to textures glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textures[0]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, textures[1]); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, textures[2]); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, depthrenderbuffer); Here is an extract of my code. I can't think of anything else to include. I've really been butting my head into a wall trying to think of a reason but I can think of none and all my research yields nothing. Thanks in advance!
    • By Adrianensis
      Hi everyone, I've shared my 2D Game Engine source code. It's the result of 4 years working on it (and I still continue improving features ) and I want to share with the community. You can see some videos on youtube and some demo gifs on my twitter account.
      This Engine has been developed as End-of-Degree Project and it is coded in Javascript, WebGL and GLSL. The engine is written from scratch.
      This is not a professional engine but it's for learning purposes, so anyone can review the code an learn basis about graphics, physics or game engine architecture. Source code on this GitHub repository.
      I'm available for a good conversation about Game Engine / Graphics Programming
    • By C0dR
      I would like to introduce the first version of my physically based camera rendering library, written in C++, called PhysiCam.
      Physicam is an open source OpenGL C++ library, which provides physically based camera rendering and parameters. It is based on OpenGL and designed to be used as either static library or dynamic library and can be integrated in existing applications.
       
      The following features are implemented:
      Physically based sensor and focal length calculation Autoexposure Manual exposure Lense distortion Bloom (influenced by ISO, Shutter Speed, Sensor type etc.) Bokeh (influenced by Aperture, Sensor type and focal length) Tonemapping  
      You can find the repository at https://github.com/0x2A/physicam
       
      I would be happy about feedback, suggestions or contributions.

    • By altay
      Hi folks,
      Imagine we have 8 different light sources in our scene and want dynamic shadow map for each of them. The question is how do we generate shadow maps? Do we render the scene for each to get the depth data? If so, how about performance? Do we deal with the performance issues just by applying general methods (e.g. frustum culling)?
      Thanks,
       
  • Popular Now