Added support for relative line numbers.

Added instructions for, brk and cont. (They are still untested...)
Parser code cleanup. Removed garbage output to stderr.
Reorganize the repository structure.
Updated BLR2 code move it into archive.
Added BLR1 files.

1 files changed, 884 insertions, 0 deletions

diff --git a/archive/hgewin/system.cpp b/archive/hgewin/system.cpp
new file mode 100755
index 0000000..2cbd741
--- /dev/null
+++ b/archive/hgewin/system.cpp
@@ -0,0 +1,884 @@
+/*
+** Haaf's Game Engine 1.8
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** Core system functions
+** Upgraded to DirectX9 By Chris Xiong, 2013/08/08
+*/
+
+
+#include "hge_impl.h"
+
+
+#define LOWORDINT(n) ((int)((signed short)(LOWORD(n))))
+#define HIWORDINT(n) ((int)((signed short)(HIWORD(n))))

+static const char* SYSTEM_SRC_FN="hge/system.cpp";
+
+
+const char *WINDOW_CLASS_NAME = "HGE__WNDCLASS";
+
+LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
+
+
+int			nRef=0;
+HGE_Impl*	pHGE=0;
+
+
+
+BOOL APIENTRY DllMain(HANDLE, DWORD, LPVOID)
+{
+    return TRUE;
+}
+
+
+HGE* CALL hgeCreate(int ver)
+{
+	if(ver==HGE_VERSION)
+		return (HGE*)HGE_Impl::_Interface_Get();
+	else
+		return 0;
+}
+
+
+HGE_Impl* HGE_Impl::_Interface_Get()
+{
+	if(!pHGE) pHGE=new HGE_Impl();
+
+	nRef++;
+
+	return pHGE;
+}
+
+
+void CALL HGE_Impl::Release()
+{
+	nRef--;
+
+	if(!nRef)
+	{
+		if(pHGE->hwnd) pHGE->System_Shutdown();
+		Resource_RemoveAllPacks();
+		delete pHGE;
+		pHGE=0;
+	}
+}
+
+
+bool CALL HGE_Impl::System_Initiate()
+{
+	OSVERSIONINFO	os_ver;
+	SYSTEMTIME		tm;
+	MEMORYSTATUS	mem_st;
+	WNDCLASS		winclass;
+	int				width, height;
+
+	// Log system info
+
+	System_Log("%s: HGE Started...",SYSTEM_SRC_FN);
+
+	System_Log("%s: hge version: %X.%X", SYSTEM_SRC_FN, HGE_VERSION>>8, HGE_VERSION & 0xFF);
+	GetLocalTime(&tm);
+	System_Log("%s: Date: %02d.%02d.%d, %02d:%02d:%02d\n", SYSTEM_SRC_FN, tm.wDay, tm.wMonth, tm.wYear, tm.wHour, tm.wMinute, tm.wSecond);
+
+	System_Log("%s: Application: %s", SYSTEM_SRC_FN, szWinTitle);
+	os_ver.dwOSVersionInfoSize=sizeof(os_ver);
+	GetVersionEx(&os_ver);
+	System_Log("%s: OS: Windows %ld.%ld.%ld", SYSTEM_SRC_FN, os_ver.dwMajorVersion,os_ver.dwMinorVersion,os_ver.dwBuildNumber);
+
+	GlobalMemoryStatus(&mem_st);
+	System_Log("%s: Memory: %ldK total, %ldK free\n", SYSTEM_SRC_FN, mem_st.dwTotalPhys/1024L,mem_st.dwAvailPhys/1024L);
+
+
+	// Register window class
+	
+	winclass.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
+	winclass.lpfnWndProc	= WindowProc;
+	winclass.cbClsExtra		= 0;
+	winclass.cbWndExtra		= 0;
+	winclass.hInstance		= hInstance;
+	winclass.hCursor		= LoadCursor(NULL, IDC_ARROW);
+	winclass.hbrBackground	= (HBRUSH)GetStockObject(BLACK_BRUSH);
+	winclass.lpszMenuName	= NULL; 
+	winclass.lpszClassName	= WINDOW_CLASS_NAME;
+	if(szIcon) winclass.hIcon = LoadIcon(hInstance, szIcon);
+	else winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+	
+	if (!RegisterClass(&winclass)) {
+		_PostError("Can't register window class");
+		return false;
+	}
+
+	// Create window
+
+	width=nScreenWidth + GetSystemMetrics(SM_CXFIXEDFRAME)*2;
+	height=nScreenHeight + GetSystemMetrics(SM_CYFIXEDFRAME)*2 + GetSystemMetrics(SM_CYCAPTION);
+
+	rectW.left=(GetSystemMetrics(SM_CXSCREEN)-width)/2;
+	rectW.top=(GetSystemMetrics(SM_CYSCREEN)-height)/2;
+	rectW.right=rectW.left+width;
+	rectW.bottom=rectW.top+height;
+	styleW=WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_VISIBLE; //WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX;
+
+	rectFS.left=0;
+	rectFS.top=0;
+	rectFS.right=nScreenWidth;
+	rectFS.bottom=nScreenHeight;
+	styleFS=WS_POPUP|WS_VISIBLE; //WS_POPUP
+
+	if(hwndParent)
+	{
+		rectW.left=0;
+		rectW.top=0;
+		rectW.right=nScreenWidth;
+		rectW.bottom=nScreenHeight;
+		styleW=WS_CHILD|WS_VISIBLE; 
+		bWindowed=true;
+	}
+
+	if(bWindowed)
+		hwnd = CreateWindowEx(0, WINDOW_CLASS_NAME, szWinTitle, styleW,
+				rectW.left, rectW.top, rectW.right-rectW.left, rectW.bottom-rectW.top,
+				hwndParent, NULL, hInstance, NULL);
+	else
+		hwnd = CreateWindowEx(WS_EX_TOPMOST, WINDOW_CLASS_NAME, szWinTitle, styleFS,
+				0, 0, 0, 0,
+				NULL, NULL, hInstance, NULL);
+	if (!hwnd)
+	{
+		_PostError("Can't create window");
+		return false;
+	}
+
+	ShowWindow(hwnd, SW_SHOW);
+
+	// Init subsystems
+
+	timeBeginPeriod(1);
+	Random_Seed();
+	//_InitPowerStatus();
+	_InputInit();
+	if(!_GfxInit()) { System_Shutdown(); return false; }
+	if(!_SoundInit()) { System_Shutdown(); return false; }
+
+	System_Log("%s: Init done.\n",SYSTEM_SRC_FN);
+
+	fTime=0.0f;
+	t0=t0fps=timeGetTime();
+	dt=cfps=0;
+	nFPS=0;
+	nFPSf=0.0f;
+	Fcnt=0;
+	fUpdateFPSDelay=0.0f;
+
+	// Show splash
+
+#ifdef DEMO
+
+	bool			(*func)();
+	bool			(*rfunc)();
+	HWND			hwndTmp;
+
+	if(pHGE->bDMO)
+	{
+		Sleep(200);
+		func=(bool(*)())pHGE->System_GetStateFunc(HGE_FRAMEFUNC);
+		rfunc=(bool(*)())pHGE->System_GetStateFunc(HGE_RENDERFUNC);
+		hwndTmp=hwndParent; hwndParent=0;
+		pHGE->System_SetStateFunc(HGE_FRAMEFUNC, DFrame);
+		pHGE->System_SetStateFunc(HGE_RENDERFUNC, 0);
+		DInit();
+		pHGE->System_Start();
+		DDone();
+		hwndParent=hwndTmp;
+		pHGE->System_SetStateFunc(HGE_FRAMEFUNC, func);
+		pHGE->System_SetStateFunc(HGE_RENDERFUNC, rfunc);
+	}
+
+#endif
+
+	// Done
+
+	return true;
+}
+
+void CALL HGE_Impl::System_Shutdown()
+{
+	System_Log("\n%s: Closing session..",SYSTEM_SRC_FN);
+
+	timeEndPeriod(1);
+	if(hSearch) { FindClose(hSearch); hSearch=0; }
+	_ClearQueue();
+	_SoundDone();
+	_GfxDone();
+	//_DonePowerStatus();
+
+	if(hwnd)
+	{
+		//ShowWindow(hwnd, SW_HIDE);
+		//SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_TOOLWINDOW);
+		//ShowWindow(hwnd, SW_SHOW);
+		DestroyWindow(hwnd);
+		hwnd=0;
+	}
+
+	if(hInstance) UnregisterClass(WINDOW_CLASS_NAME, hInstance);
+
+	System_Log("%s: Session ended.",SYSTEM_SRC_FN);
+}
+
+
+bool CALL HGE_Impl::System_Start()
+{
+	MSG		msg;
+
+	if(!hwnd)
+	{
+		_PostError("System_Start: System_Initiate wasn't called");
+		return false;
+	}
+
+	if(!procFrameFunc) {
+		_PostError("System_Start: No frame function defined");
+		return false;
+	}
+
+	bActive=true;
+
+	// MAIN LOOP
+
+	for(;;)
+	{
+		
+		// Process window messages if not in "child mode"
+		// (if in "child mode" the parent application will do this for us)
+
+		if(!hwndParent)
+		{
+			if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
+			{ 
+				if (msg.message == WM_QUIT)	break;
+				// TranslateMessage(&msg);
+				DispatchMessage(&msg);
+				continue;
+			}
+		}
+
+		// Check if mouse is over HGE window for Input_IsMouseOver
+
+		_UpdateMouse();
+
+		// If HGE window is focused or we have the "don't suspend" state - process the main loop
+
+		if(bActive || bDontSuspend)
+		{
+			// Ensure we have at least 1ms time step
+			// to not confuse user's code with 0
+
+			do { dt=timeGetTime() - t0; } while(dt < 1);
+
+			// If we reached the time for the next frame
+			// or we just run in unlimited FPS mode, then
+			// do the stuff
+
+			if(dt >= nFixedDelta)
+			{
+				// fDeltaTime = time step in seconds returned by Timer_GetDelta
+
+				fDeltaTime=dt/1000.0f;
+
+				// Cap too large time steps usually caused by lost focus to avoid jerks
+
+				if(fDeltaTime > 0.2f)
+				{
+					fDeltaTime = nFixedDelta ? nFixedDelta/1000.0f : 0.01f;
+				}
+
+				// Update time counter returned Timer_GetTime
+
+				fTime += fDeltaTime;
+
+				// Store current time for the next frame
+				// and count FPS
+
+				t0=timeGetTime();
+				if(t0-t0fps <= 1000) cfps++;
+				else
+				{
+					nFPS=cfps; cfps=0; t0fps=t0;
+					_UpdatePowerStatus();
+				}
+				++Fcnt;fUpdateFPSDelay+=fDeltaTime;
+				if(fUpdateFPSDelay>1)
+				{
+					nFPSf=Fcnt/fUpdateFPSDelay;
+					fUpdateFPSDelay=0.0f;
+					Fcnt=0;
+				}
+				// Do user's stuff
+
+				if(procFrameFunc()) break;
+				if(procRenderFunc) procRenderFunc();
+				
+				// If if "child mode" - return after processing single frame
+
+				if(hwndParent) break;
+
+				// Clean up input events that were generated by
+				// WindowProc and weren't handled by user's code
+				for (int i=1;i<=255;++i)
+					keylast[i]=Input_GetKeyState(i);
+				_ClearQueue();
+
+				// If we use VSYNC - we could afford a little
+				// sleep to lower CPU usage
+
+				// if(!bWindowed && nHGEFPS==HGEFPS_VSYNC) Sleep(1);
+			}
+
+			// If we have a fixed frame rate and the time
+			// for the next frame isn't too close, sleep a bit
+
+			else
+			{
+				if(nFixedDelta && dt+3 < nFixedDelta) Sleep(1);
+			}
+		}
+
+		// If main loop is suspended - just sleep a bit
+		// (though not too much to allow instant window
+		// redraw if requested by OS)
+
+		else Sleep(1);
+	}
+
+	_ClearQueue();
+
+	bActive=false;
+
+	return true;
+}
+
+void CALL HGE_Impl::System_SetStateBool(hgeBoolState state, bool value)
+{
+	switch(state)
+	{
+		case HGE_WINDOWED:		if(VertArray || hwndParent) break;
+								if(pD3DDevice && bWindowed != value)
+								{
+									if(d3dppW.BackBufferFormat==D3DFMT_UNKNOWN || d3dppFS.BackBufferFormat==D3DFMT_UNKNOWN) break;
+
+									if(bWindowed) GetWindowRect(hwnd, &rectW);
+									bWindowed=value;
+									if(bWindowed) d3dpp=&d3dppW;
+									else d3dpp=&d3dppFS;
+
+									if(_format_id(d3dpp->BackBufferFormat) < 4) nScreenBPP=16;
+									else nScreenBPP=32;
+
+									_GfxRestore();
+									_AdjustWindow();
+								}
+								else bWindowed=value;
+								break;
+
+		case HGE_ZBUFFER:		if(!pD3DDevice)	bZBuffer=value;
+								break;
+
+		case HGE_TEXTUREFILTER: bTextureFilter=value;
+								if(pD3DDevice)
+								{
+									_render_batch();
+									if(bTextureFilter)
+									{
+										pD3DDevice->SetSamplerState(0,D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
+										pD3DDevice->SetSamplerState(0,D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
+									}
+									else
+									{
+										pD3DDevice->SetSamplerState(0,D3DSAMP_MAGFILTER,D3DTEXF_POINT);
+										pD3DDevice->SetSamplerState(0,D3DSAMP_MINFILTER,D3DTEXF_POINT);
+									}
+								}
+								break;
+
+		case HGE_USESOUND:		if(bUseSound!=value)
+								{
+									bUseSound=value;
+									if(bUseSound && hwnd) _SoundInit();
+									if(!bUseSound && hwnd) _SoundDone();
+								}
+								break;
+
+		case HGE_HIDEMOUSE:		bHideMouse=value; break;
+
+		case HGE_DONTSUSPEND:	bDontSuspend=value; break;
+
+		#ifdef DEMO
+		case HGE_SHOWSPLASH:	bDMO=value; break;
+		#endif
+	}
+}
+
+void CALL HGE_Impl::System_SetStateFunc(hgeFuncState state, hgeCallback value)
+{
+	switch(state)
+	{
+		case HGE_FRAMEFUNC:		 procFrameFunc=value; break;
+		case HGE_RENDERFUNC:	 procRenderFunc=value; break;
+		case HGE_FOCUSLOSTFUNC:	 procFocusLostFunc=value; break;
+		case HGE_FOCUSGAINFUNC:	 procFocusGainFunc=value; break;
+		case HGE_GFXRESTOREFUNC: procGfxRestoreFunc=value; break;
+		case HGE_EXITFUNC:		 procExitFunc=value; break;
+	}
+}
+
+void CALL HGE_Impl::System_SetStateHwnd(hgeHwndState state, HWND value)
+{
+	switch(state)
+	{
+		case HGE_HWNDPARENT:	if(!hwnd) hwndParent=value; break;
+	}
+}
+
+void CALL HGE_Impl::System_SetStateInt(hgeIntState state, int value)
+{
+	switch(state)
+	{
+		case HGE_SCREENWIDTH:	if(!pD3DDevice) nScreenWidth=value; break;
+
+		case HGE_SCREENHEIGHT:	if(!pD3DDevice) nScreenHeight=value; break;
+
+		case HGE_SCREENBPP:		if(!pD3DDevice) nScreenBPP=value; break;
+
+		case HGE_SAMPLERATE:	if(!hOpenAL) nSampleRate=value;
+								break;
+
+		case HGE_FXVOLUME:		nFXVolume=value;
+								_SetFXVolume(nFXVolume);
+								break;
+
+		case HGE_MUSVOLUME:		nMusVolume=value;
+								_SetMusVolume(nMusVolume);
+								break;
+
+		case HGE_STREAMVOLUME:	nStreamVolume=value;
+								_SetStreamVolume(nStreamVolume);
+								break;
+
+		case HGE_FPS:			if(VertArray) break;
+
+								if(pD3DDevice)
+								{
+									if((nHGEFPS>=0 && value <0) || (nHGEFPS<0 && value>=0))
+									{
+										if(value==HGEFPS_VSYNC)
+										{
+											d3dppW.SwapEffect = D3DSWAPEFFECT_COPY;
+											d3dppW.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
+											d3dppFS.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
+										}
+										else
+										{
+											d3dppW.SwapEffect = D3DSWAPEFFECT_COPY;
+											d3dppFS.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
+										}
+										//if(procFocusLostFunc) procFocusLostFunc();
+										_GfxRestore();
+										//if(procFocusGainFunc) procFocusGainFunc();
+									}
+								}
+								nHGEFPS=value;
+								if(nHGEFPS>0) nFixedDelta=int(1000.0f/value);
+								else nFixedDelta=0;
+								break;
+	}
+}
+
+void CALL HGE_Impl::System_SetStateString(hgeStringState state, const char *value)
+{
+	FILE *hf;
+	
+	switch(state)
+	{
+		case HGE_ICON:			szIcon=value;
+								if(pHGE->hwnd) SetClassLong(pHGE->hwnd, GCL_HICON, (LONG)LoadIcon(pHGE->hInstance, szIcon));
+								break;
+		case HGE_TITLE:			strcpy(szWinTitle,value);
+								if(pHGE->hwnd) SetWindowText(pHGE->hwnd, szWinTitle);
+								break;
+		case HGE_INIFILE:		if(value) strcpy(szIniFile,Resource_MakePath(value));
+								else szIniFile[0]=0;
+								break;
+		case HGE_LOGFILE:		if(value)
+								{
+									strcpy(szLogFile,Resource_MakePath(value));
+									hf=fopen(szLogFile, "w");
+									if(!hf) szLogFile[0]=0;
+									else fclose(hf);
+								}
+								else szLogFile[0]=0;
+								break;
+	}
+}
+
+bool CALL HGE_Impl::System_GetStateBool(hgeBoolState state)
+{
+	switch(state)
+	{
+		case HGE_WINDOWED:		return bWindowed;
+		case HGE_ZBUFFER:		return bZBuffer;
+		case HGE_TEXTUREFILTER:	return bTextureFilter;
+		case HGE_USESOUND:		return bUseSound;
+		case HGE_DONTSUSPEND:	return bDontSuspend;
+		case HGE_HIDEMOUSE:		return bHideMouse;
+
+		#ifdef DEMO
+		case HGE_SHOWSPLASH:	return bDMO;
+		#endif
+	}
+
+	return false;
+}
+
+hgeCallback CALL HGE_Impl::System_GetStateFunc(hgeFuncState state)
+{
+	switch(state)
+	{
+		case HGE_FRAMEFUNC:		return procFrameFunc;
+		case HGE_RENDERFUNC:	return procRenderFunc;
+		case HGE_FOCUSLOSTFUNC:	return procFocusLostFunc;
+		case HGE_FOCUSGAINFUNC:	return procFocusGainFunc;
+		case HGE_EXITFUNC:		return procExitFunc;
+	}
+
+	return NULL;
+}
+
+HWND CALL HGE_Impl::System_GetStateHwnd(hgeHwndState state)
+{
+	switch(state)
+	{
+		case HGE_HWND:			return hwnd;
+		case HGE_HWNDPARENT:	return hwndParent;
+	}
+
+	return 0;
+}
+
+int CALL HGE_Impl::System_GetStateInt(hgeIntState state)
+{
+	switch(state)
+	{
+		case HGE_SCREENWIDTH:	return nScreenWidth;
+		case HGE_SCREENHEIGHT:	return nScreenHeight;
+		case HGE_SCREENBPP:		return nScreenBPP;
+		case HGE_SAMPLERATE:	return nSampleRate;
+		case HGE_FXVOLUME:		return nFXVolume;
+		case HGE_MUSVOLUME:		return nMusVolume;
+		case HGE_STREAMVOLUME:	return nStreamVolume;
+		case HGE_FPS:			return nHGEFPS;
+		case HGE_POWERSTATUS:	return nPowerStatus;
+	}
+
+	return 0;
+}
+
+const char* CALL HGE_Impl::System_GetStateString(hgeStringState state) {
+	switch(state) {
+		case HGE_ICON:			return szIcon;
+		case HGE_TITLE:			return szWinTitle;
+		case HGE_INIFILE:		if(szIniFile[0]) return szIniFile;
+								else return 0;
+		case HGE_LOGFILE:		if(szLogFile[0]) return szLogFile;
+								else return 0;
+	}
+
+	return NULL;
+}
+
+const char* CALL HGE_Impl::System_GetErrorMessage()
+{
+	return szError;
+}
+
+void CALL HGE_Impl::System_Log(const char *szFormat, ...)
+{
+	FILE *hf = NULL;
+	va_list ap;
+	
+	if(!szLogFile[0]) return;
+
+	hf = fopen(szLogFile, "a");
+	if(!hf) return;
+
+	va_start(ap, szFormat);
+	vfprintf(hf, szFormat, ap);
+	va_end(ap);
+	va_start(ap, szFormat);

+	vfprintf(stderr, szFormat, ap);

+	va_end(ap);
+	fprintf(hf, "\n");
+	fprintf(stderr, "\n");
+
+	fclose(hf);
+}
+
+bool CALL HGE_Impl::System_Launch(const char *url)
+{
+	if((DWORD)ShellExecute(pHGE->hwnd, NULL, url, NULL, NULL, SW_SHOWMAXIMIZED)>32) return true;
+	else return false;
+}
+
+void CALL HGE_Impl::System_Snapshot(const char *filename)
+{
+	LPDIRECT3DSURFACE9 pSurf;
+	char *shotname, tempname[_MAX_PATH];
+	int i;
+
+	if(!filename)
+	{
+		i=0;
+		shotname=Resource_EnumFiles("shot???.bmp");
+		while(shotname)
+		{
+			i++;
+			shotname=Resource_EnumFiles();
+		}
+		sprintf(tempname, "shot%03d.bmp", i);
+		filename=Resource_MakePath(tempname);
+	}
+
+	if(pD3DDevice)
+	{
+		pD3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pSurf);
+		D3DXSaveSurfaceToFile(filename, D3DXIFF_BMP, pSurf, NULL, NULL);
+		pSurf->Release();
+	}
+}
+
+//////// Implementation ////////
+
+
+HGE_Impl::HGE_Impl()
+{
+	hInstance=GetModuleHandle(0);
+	hwnd=0;
+	bActive=false;
+	szError[0]=0;
+
+	pD3D=0;
+	pD3DDevice=0;
+	d3dpp=0;
+	pTargets=0;
+	pCurTarget=0;
+	pScreenSurf=0;
+	pScreenDepth=0;
+	pVB=0;
+	pIB=0;
+	VertArray=0;
+	textures=0;
+
+	hOpenAL=0;
+	bSilent=false;
+	streams=0;
+
+	hSearch=0;
+	res=0;
+
+	queue=0;
+	Char=VKey=Zpos=0;
+	Xpos=Ypos=0.0f;
+	bMouseOver=false;
+	bCaptured=false;
+
+	nHGEFPS=HGEFPS_UNLIMITED;
+	fTime=0.0f;
+	fUpdateFPSDelay=0.0f;
+	fDeltaTime=0.0f;
+	nFPS=0;
+	nFPSf=0.0f;
+	Fcnt=0;
+	
+	procFrameFunc=0;
+	procRenderFunc=0;
+	procFocusLostFunc=0;
+	procFocusGainFunc=0;
+	procGfxRestoreFunc=0;
+	procExitFunc=0;
+	szIcon=0;
+	strcpy(szWinTitle,"HGE");
+	nScreenWidth=800;
+	nScreenHeight=600;
+	nScreenBPP=32;
+	bWindowed=false;
+	bZBuffer=false;
+	bTextureFilter=true;
+	szLogFile[0]=0;
+	szIniFile[0]=0;
+	bUseSound=true;
+	nSampleRate=44100;
+	nFXVolume=100;
+	nMusVolume=100;
+	nStreamVolume=100;
+	nFixedDelta=0;
+	bHideMouse=true;
+	bDontSuspend=false;
+	hwndParent=0;
+
+	nPowerStatus=HGEPWR_UNSUPPORTED;
+	hKrnl32 = NULL;
+	lpfnGetSystemPowerStatus = NULL;
+
+#ifdef DEMO
+	bDMO=true;
+#endif
+
+
+	GetModuleFileName(GetModuleHandle(NULL), szAppPath, sizeof(szAppPath));
+	int i;
+	for(i=strlen(szAppPath)-1; i>0; i--) if(szAppPath[i]=='\\') break;
+	szAppPath[i+1]=0;
+}
+
+void HGE_Impl::_PostError(const char *error)
+{
+	System_Log(error);
+	strcpy(szError,error);
+}
+
+void HGE_Impl::_FocusChange(bool bAct)
+{
+	bActive=bAct;
+
+	if(bActive)
+	{
+		if(procFocusGainFunc) procFocusGainFunc();
+	}
+	else
+	{
+		if(procFocusLostFunc) procFocusLostFunc();
+	}
+}
+
+LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
+{
+	bool bActivating;
+
+	switch(msg)
+	{	
+		case WM_CREATE: 
+			return FALSE;
+		
+		case WM_PAINT:
+			if(pHGE->pD3D && pHGE->procRenderFunc && pHGE->bWindowed) pHGE->procRenderFunc();
+			break;
+
+		case WM_DESTROY:
+			PostQuitMessage(0);
+			return FALSE;
+
+/*
+		case WM_ACTIVATEAPP:
+			bActivating = (wparam == TRUE);
+			if(pHGE->pD3D && pHGE->bActive != bActivating) pHGE->_FocusChange(bActivating);
+			return FALSE;
+*/
+		case WM_ACTIVATE:
+			// tricky: we should catch WA_ACTIVE and WA_CLICKACTIVE,
+			// but only if HIWORD(wParam) (fMinimized) == FALSE (0)
+			bActivating = (LOWORD(wparam) != WA_INACTIVE) && (HIWORD(wparam) == 0);
+			if(pHGE->pD3D && pHGE->bActive != bActivating) pHGE->_FocusChange(bActivating);
+			return FALSE;
+
+
+		case WM_SETCURSOR:
+			if(pHGE->bActive && LOWORD(lparam)==HTCLIENT && pHGE->bHideMouse) SetCursor(NULL);
+			else SetCursor(LoadCursor(NULL, IDC_ARROW));
+			return FALSE;
+
+		case WM_SYSKEYDOWN:
+			if(wparam == VK_F4)
+			{
+				if(pHGE->procExitFunc && !pHGE->procExitFunc()) return FALSE;
+				return DefWindowProc(hwnd, msg, wparam, lparam);
+			}
+			else if(wparam == VK_RETURN)
+			{
+				pHGE->System_SetState(HGE_WINDOWED, !pHGE->System_GetState(HGE_WINDOWED));
+				return FALSE;
+			}
+			else
+			{
+				pHGE->_BuildEvent(INPUT_KEYDOWN, wparam, HIWORD(lparam) & 0xFF, (lparam & 0x40000000) ? HGEINP_REPEAT:0, -1, -1);
+				return FALSE;
+			}
+
+		case WM_KEYDOWN:
+			pHGE->_BuildEvent(INPUT_KEYDOWN, wparam, HIWORD(lparam) & 0xFF, (lparam & 0x40000000) ? HGEINP_REPEAT:0, -1, -1);
+			return FALSE;
+		case WM_SYSKEYUP:
+			pHGE->_BuildEvent(INPUT_KEYUP, wparam, HIWORD(lparam) & 0xFF, 0, -1, -1);
+			return FALSE;
+		case WM_KEYUP:
+			pHGE->_BuildEvent(INPUT_KEYUP, wparam, HIWORD(lparam) & 0xFF, 0, -1, -1);
+			return FALSE;
+
+		case WM_LBUTTONDOWN:
+			SetFocus(hwnd);
+			pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_LBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+		case WM_MBUTTONDOWN:
+			SetFocus(hwnd);
+			pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_MBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+		case WM_RBUTTONDOWN:
+			SetFocus(hwnd);
+			pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_RBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+
+		case WM_LBUTTONDBLCLK:
+			pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_LBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+		case WM_MBUTTONDBLCLK:
+			pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_MBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+		case WM_RBUTTONDBLCLK:
+			pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_RBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+
+		case WM_LBUTTONUP:
+			pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_LBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+		case WM_MBUTTONUP:
+			pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_MBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+		case WM_RBUTTONUP:
+			pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_RBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+
+		case WM_MOUSEMOVE:
+			pHGE->_BuildEvent(INPUT_MOUSEMOVE, 0, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+		case 0x020A: // WM_MOUSEWHEEL, GET_WHEEL_DELTA_WPARAM(wparam);
+			pHGE->_BuildEvent(INPUT_MOUSEWHEEL, short(HIWORD(wparam))/120, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
+			return FALSE;
+
+		case WM_SIZE:
+			if(pHGE->pD3D && wparam==SIZE_RESTORED) pHGE->_Resize(LOWORD(lparam), HIWORD(lparam));
+			//return FALSE;
+			break;
+
+		case WM_SYSCOMMAND:
+			if(wparam==SC_CLOSE)
+			{
+				if(pHGE->procExitFunc && !pHGE->procExitFunc()) return FALSE;
+				pHGE->bActive=false;
+				return DefWindowProc(hwnd, msg, wparam, lparam);
+			}
+			break;
+	}
+
+	return DefWindowProc(hwnd, msg, wparam, lparam);
+}
+