Jump to content
  • Advertisement
Sign in to follow this  
juanmanuelsanchez

Bitmap font problem

This topic is 4248 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

well Im having problems to get the bitmap font to work, I cant see anything in the viewport. The thing is... it seems to work with Ortho perspective but not with gluPerspective. Is there a explanation for this? Here is the code Bitmap.h
extern HDC hDC;

class BitMapFont {

	unsigned int m_fontListBase;

	unsigned int CreateBitmapFont(char *fontName, int fontSize);
	void RenderFont(int xPos, int yPos, unsigned int base, const char *str);
	void RenderFont(int xPos, int yPos, unsigned int base, float *str);
	void ReleaseFont(unsigned int base);

public:
	BitMapFont();
	virtual ~BitMapFont();

	bool Init();
	bool Shutdown();
	void Prepare(float dt);
	void Render(int xpos, int ypos,const char* str);
	void Render(int xpos, int ypos,float* str);
};

#endif


Bitmap.cpp
BitMapFont::BitMapFont()
{
}

BitMapFont::~BitMapFont()
{
}

bool BitMapFont::Init()
{		

	glClearColor(0.0, 0.0, 0.0, 0.0);
	m_fontListBase = CreateBitmapFont("Verdana", 13);
	return true;
}

bool BitMapFont::Shutdown()
{
	ReleaseFont(m_fontListBase);

	return true;
}



unsigned int BitMapFont::CreateBitmapFont(char *fontName, int fontSize)
{
	HFONT hFont;     // the windows font
	unsigned int base;

	base = glGenLists(96);

	if (!stricmp(fontName, "symbol"))
	{
		hFont = CreateFont(fontSize, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE,
							SYMBOL_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS,
							ANTIALIASED_QUALITY, FF_DONTCARE | DEFAULT_PITCH,
							fontName);
	}
	else
	{
		hFont = CreateFont(fontSize, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE,
							ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS,
							ANTIALIASED_QUALITY, FF_DONTCARE | DEFAULT_PITCH,
							fontName);
	}

	if (!hFont)
		return 0;
    
	SelectObject(hDC, hFont);
	wglUseFontBitmaps(hDC, 32, 96, base);

	return base;
}

void BitMapFont::ReleaseFont(unsigned int base)
{
	if (base != 0)
		glDeleteLists(base, 96);
}

void BitMapFont::RenderFont(int xPos, int yPos, unsigned int base,const char *str)
{
	if ((base == 0) || (!str))
		return;

	glRasterPos2i(xPos, yPos);
	glPushAttrib(GL_LIST_BIT);
		glListBase(base - 32);
		glCallLists((int)strlen(str), GL_UNSIGNED_BYTE, str);
	glPopAttrib();
}
void BitMapFont::Render(int xpos, int ypos, const char* str)
{
	// clear screen and depth buffer
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// load the identity matrix (clear to default position and orientation)
	glLoadIdentity();
    //glTranslatef(10.0, -1.0, -80.0f);
	glColor3f(8.0f, 1.0f, 2.0f);
	RenderFont(xpos, ypos, m_fontListBase,str);
}


And the main
bool exiting = false;
long windowWidth = 1024;
long windowHeight = 768;
long windowBits = 32;
bool fullscreen = false;
bool	keys[256];			// Array Used For The Keyboard Routine
int mouseX, mouseY;
HDC hDC;
UINT	MouseX, MouseY;		// Coordinates for the mouse
UINT	CenterX, CenterY;	// Coordinates for the center of the screen.

void CheckMouse(void);		// Function Prototypes
void CameraMovement(void);

CGfxOpenGL *g_glRender = NULL;
CHiResTimer *g_hiResTimer = NULL;
ASE *g_ASE=NULL;
glCamera *Cam=NULL;
CGL_Light3D Lights;
BitMapFont bmF;


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)
			1,							// no accumulation buffer
			0, 0, 0, 0,					// accum bits (ignored)
			16,							// depth buffer
			1,							// no stencil buffer
			1,							// no auxiliary buffers
			PFD_MAIN_PLANE,				// main layer
			0,							// reserved
			0, 0, 0,					// no layer, visible, damage masks
	};

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


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

	char str[40] = {'\0'};


	// 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);

		CenterX = LOWORD(lParam) / 2;
		CenterY = HIWORD(lParam) / 2;

		SetCursorPos(CenterX, CenterY);
		g_glRender->SetupProjection(width, height);
		break;

	case WM_ACTIVATEAPP:		// activate app
		break;

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

	case WM_LBUTTONDOWN:		// left mouse button
	
	
//		g_glRender->Get3DIntersection(xPos, yPos, x, y, z);
//		g_chessGame->OnSelection((float)z, (float)x);
		break;

	case WM_RBUTTONDOWN:		// right mouse button
		break;

	case WM_MOUSEMOVE:	
	//	Cam.SetPrespective();
        //CheckMouse();
		//outs("mouse.y",((mouse.y)/100.0f),0);
		//outs("mouse.x",((mouse.x)/100.0f),0);
//	   Camera.CheckMouse();
		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 
        outs("fwKeys ",fwKeys,0);

		switch(fwKeys)
		{
		case VK_ESCAPE:
			PostQuitMessage(0);
			break;
        case 65:
		Cam->ChangeHeading(-5.0f);
			break;
		 case 68:
		Cam->ChangeHeading(5.0f);
			break;
		 case 39:
			
			break;
		case 40:
			
			break;
		case 87:
			Cam->ChangeVelocity(0.5f);
			break;

		case 83:
			Cam->ChangeVelocity(-0.5f);
			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;
	g_hiResTimer = new CHiResTimer;
//	g_chessGame = new CChessGame;
	g_ASE=new ASE;
	Cam=new glCamera;
	Lights.Init(0);
    
	

	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(&windowClass))
		return 0;

	if (fullscreen)								// fullscreen?
	{
		DEVMODE dmScreenSettings;					// device mode
		memset(&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_PELSWIDTH|DM_PELSHEIGHT;

		// 
		if (ChangeDisplaySettings(&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(&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
		"FPSoccer",	// 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
	if (!g_glRender->Init())
	{
		MessageBox(NULL, "CGfxOpenGL::Init() error!", "CGfxOpenGL class failed to initialize!", MB_OK);
		return -1;
	}
    
	g_hiResTimer->Init();
	//g_chessGame->Initialize();
	Cam->InitCamera();
    bmF.Init();
	Lights.Init(GL_LIGHT0);
	

	FILE *pFile= fopen("Data/Models/manta.ASE","r");
	
	if(pFile!=NULL){

	outs("file opened",0);
	g_ASE->SetPath("Data/Models/");
	bool loaded=false;
	loaded=g_ASE->loadFromFile(pFile);
	g_ASE->displaylist();     
	}
	else{
	outs("file not found",1);
	}
	
	fclose(pFile);
	

	//g_glRender->AttachToGame(g_chessGame);
	

	
	while (!exiting)
	{
	//	g_glRender->Prepare(g_hiResTimer->GetElapsedSeconds(1));
		g_glRender->Render();
        bmF.Render(0,windowWidth/windowWidth,"HELLO USA!!!");
        CameraMovement();
		g_ASE->render();

		SwapBuffers(hDC);

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

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

	//delete g_chessGame;
	delete g_hiResTimer;
	delete g_glRender;
	delete g_ASE;
	Lights.TurnOffAllLights();
	bmF.Shutdown();


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

	return (int)msg.wParam;
}


[Edited by - juanmanuelsanchez on February 1, 2007 2:23:25 PM]

Share this post


Link to post
Share on other sites
Advertisement
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!