[HGE]-源码分析-13system （b）

    所有的GET和SET

在接口里它们只是很低调的两个函数



但是。。这个和DX里SetRanderState形式一样的函数的实现有好多个

看名字可以直接可以知道是按输入类型分的
具体的它们的使用方式看一眼hge.h里的一段代码就清楚了

private:
virtual void		CALL	System_SetStateBool  (hgeBoolState   state, bool        value) = 0;
virtual void		CALL	System_SetStateFunc  (hgeFuncState   state, hgeCallback value) = 0;
virtual void		CALL	System_SetStateHwnd  (hgeHwndState   state, HWND        value) = 0;
virtual void		CALL	System_SetStateInt   (hgeIntState    state, int         value) = 0;
virtual void		CALL	System_SetStateString(hgeStringState state, const char *value) = 0;
virtual bool		CALL	System_GetStateBool  (hgeBoolState   state) = 0;
virtual hgeCallback	CALL	System_GetStateFunc  (hgeFuncState   state) = 0;
virtual HWND		CALL	System_GetStateHwnd  (hgeHwndState   state) = 0;
virtual int			CALL	System_GetStateInt   (hgeIntState    state) = 0;
virtual const char*	CALL	System_GetStateString(hgeStringState state) = 0;

public:
inline void					System_SetState(hgeBoolState   state, bool        value) { System_SetStateBool  (state, value); }
inline void					System_SetState(hgeFuncState   state, hgeCallback value) { System_SetStateFunc  (state, value); }
inline void					System_SetState(hgeHwndState   state, HWND        value) { System_SetStateHwnd  (state, value); }
inline void					System_SetState(hgeIntState    state, int         value) { System_SetStateInt   (state, value); }
inline void					System_SetState(hgeStringState state, const char *value) { System_SetStateString(state, value); }
inline bool					System_GetState(hgeBoolState   state) { return System_GetStateBool  (state); }
inline hgeCallback			System_GetState(hgeFuncState   state) { return System_GetStateFunc  (state); }
inline HWND					System_GetState(hgeHwndState   state) { return System_GetStateHwnd  (state); }
inline int					System_GetState(hgeIntState    state) { return System_GetStateInt   (state); }
inline const char*			System_GetState(hgeStringState state) { return System_GetStateString(state); }

代码是这么个情况：

在hge.h里面声明了接口(private的，在hge_impl.h继承HGE后重新声明并且在system里实现)

这些函数的调用是通过HGE里的System_SetState()

我们拿到手使用的接口是HGE_Impl类的对象，由于多态的效果，调用System_SetState()的时候就会调用相应的

实现好的状态设置函数

在一个一个看这些函数之前

先看看可以设置的参数：

说明用法之后代码里面的东西就很容易明白在干什么了。

SET的

1

HGE_FRAMEFUNC

调用举例：

hge->System_SetState(HGE_FRAMEFUNC, FrameFunc);

就是在WinMain里设定我们的帧函数（每一帧都调用的函数）。

第二个参数是函数名，这个函数没有参数，返回一个bool，返回true表示退出，所以在HGE程序中要退出就让你的帧函数返回true。

2

HGE_RENDERFUNC

调用举例：

hge->System_SetState(HGE_RENDERFUNC, RenderFunc);

绘制函数，依然是每一帧都要调用的

这个绘制函数同样不带参数，而且总是返回false

3，4，5，6

HGE_GFXRESTOREFUNC

指向一个用户自定义函数，此函数会在现存内容丢失时被调用（例如：视频模式切换时）。 所有纹理会被自动恢复，此函数只对render
targets有意义。

 此函数不带参数，如果执行成功，将返回true，否则返回false。
可以在你想要的任何时间设置和改变

HGE_FOCUSLOSTFUNC

指向一个用户自定义函数，此函数会在程序失去焦点时（只是当用户切换到其他程序时，不包括程序主窗口被销毁时） 或者在显示模式改变之前被调用。

此函数不带参数，并且应该总是返回false。
可以在你想要的任何时间设置和改变。

HGE_FOCUSGAINFUNC

指向一个用户自定义函数，此函数会在程序获得焦点时（只是当用户从其他程序切换回此程序时，不包括程序主窗口被创建时）被调用。

此函数不带参数，并且应该总是返回false。
可以在你想要的任何时间设置和改变

HGE_EXITFUNC

指向一个用户自定义函数，此函数会在用户试图关闭程序时被调用。 如果你想要允许程序被终止，让此函数返回true。 

如果此函数返回false程序将继续运行。
此函数可以在你想要的任何时间设置和改变。

这几个一起说了，而且直接把他们的用法复制过来了，我也木有用过，这几个是在做比较复杂的东西的时候，用来封装一些自定义的操作

比如HGE_EXITFUNC，当程序不允许直接关闭的时候（比如需要存档的的游戏，在关闭动作发出后要提示存档）

OK，下面是关于这几个参数的函数的实现

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;
}
}

仅仅是一个赋值

把这几个函数的地址复制给相应的函数指针

7

HGE_ICON

指明主窗口图标资源

这个的实现有一些老了，一会看代码就知道了。这里的载入格式是：

hge->System_SetState(HGE_ICON,MAKEINTRESOURCE(数字));

这里的数字是资源ID，windows编程里资源管理的时候生成的那个resource.h里资源对应的宏的值

8

HGE_TITLE

hge->System_SetState(HGE_TITLE, "HGE");

标题

9

HGE_INIFILE

供HGE的Ini_XXXXX函数使用的初始化文件名,写配置文件用的，就是如果程序需要保存一些参数供下次使用，需要创建一个ini

就在这里写入它的初始化文件名

10

HGE_LOGFILE

hge->System_SetState(HGE_LOGFILE, "hge.log");

逆置文件名

4个string参数的实现代码

void CALL HGE_Impl::System_SetStateString(hgeStringState state, const char *value)
{
FILE *hf;

switch(state)
{
case HGE_ICON:			szIcon=value;                                                            //这里的loadIcon已经被loadimage代替了
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;
}
}

11

HGE_SCREENWIDTH

HGE_SCREENHEIGHT

HGE_SCREENBPP

这三个一起

hge->System_SetState(HGE_SCREENWIDTH, 800);
hge->System_SetState(HGE_SCREENHEIGHT, 600);
hge->System_SetState(HGE_SCREENBPP, 32);

设定宽高和位深

12

HGE_SAMPLERATE

所播放声音的采样率。 此值受到音频驱动性能的约束。 此标记必须在调用System_Initiate之前设置

13

HGE_FXVOLUME  声音

HGE_MUSVOLUME  音乐

HGE_STREAMVOLUME流音效

三个设定音量的

14

HGE_FPS

帧速率

int型设定的实现

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(!hBass) 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_VSYNC;
d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE;
}
else
{
d3dppW.SwapEffect = D3DSWAPEFFECT_COPY;
d3dppFS.FullScreen_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;
}
}

最后的几个布尔型

15

HGE_WINDOWED

HGE_ZBUFFER

HGE_TEXTUREFILTER

是否启用  窗口化  z缓冲 纹理过滤

16

HGE_USESOUND

是否使用HGE声音效果 

置为false之后是不使用BASS库（无声），或者自己添加声音播放

17

HGE_DONTSUSPEND

这个参数很有意思

先看它的定义：

如果此标记为true，程序将不会在其失去焦点时挂起。

平时我们的小游戏在失去焦点后一般都不动了，通过这个可以让它继续跑

18

HGE_HIDEMOUSE

隐藏指针

19

HGE_SHOWSPLASH

没有用过的

指定HGE是否要显示分屏。很明显要使之生效，此标记必须在调用System_Initiate之前设置。

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->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
}
else
{
pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_POINT);
pD3DDevice->SetTextureStageState(0,D3DTSS_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
}
}

还有差点忘掉的一个

20

HGE_HWNDPARENT

唯一的一个窗口定义

定义HGE父窗口句柄并开启子窗口模式。
此标记必须在调用System_Initiate之前设置。

具体的看文档

void CALL HGE_Impl::System_SetStateHwnd(hgeHwndState state, HWND value)
{
switch(state)
{
case HGE_HWNDPARENT:	if(!hwnd) hwndParent=value; break;
}
}

------------------------------------------------------------------

GET

get的容易的多

不过有两个只读参数（只在这里用的）

直接把文档里的贴过来

HGE_HWND

只读。如果在System_Initiate 函数和System_Shutdown函数之间被调用，将返回HGE窗口句柄，否则返回0

HGE_POWERSTATUS

只读。如果当前的点换是AC，返回HGEPWR_AC。
否则返回当前电池的电量。0-100。如果不支持显示电池状态，将返回HGEPWR_UNSUPPORTED

Get部分的代码就一起贴出来

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;
}

OK，收工

前两天出门了

那叫个远，2个多小时的路程，一出去就是一天的节奏。。。。