glayer.h

用FREE BASIC做的演示程序

#ifndef GPP_LAYER_H_
#define GPP_LAYER_H_
#include<Assert.h>
#include<windows.h>
#define MAX_LAYER	(4)
#define MAX_LEVEL	(4)
class GScreen;

class GLayerObject
{
	friend class GLayer;
	friend class GLayerManager;
public:
	GLayerObject()
	{
		m_pNext=NULL;
		m_pPrev=NULL;
		m_nLevel=0;
	}
	virtual ~GLayerObject()
	{
	}
	virtual void DrawToScreen(GScreen*pScreen)
	{
	}
	inline void Release()
	{
		if(m_pNext)
			m_pNext->m_pPrev=m_pPrev;
		if(m_pPrev)
			m_pPrev->m_pNext=m_pNext;
		delete this;
	}
	inline void SetLevel(int nLevel)
	{
		assert(nLevel>=0 && nLevel<MAX_LEVEL);
		m_nLevel=nLevel;
	}
	inline int GetLevel()const
	{
		return m_nLevel;
	}
private:
	int				m_nLevel;
	GLayerObject	*m_pNext;
	GLayerObject	*m_pPrev;
};
class GLayer
{
	friend class GLayerManager;
public:
	GLayer()
	{
		for(int i=0;i<MAX_LEVEL;i++)
		{
			m_pHead[i]=new GLayerObject();
			m_pTail[i]=new GLayerObject();
			m_pHead[i]->m_pNext=m_pTail[i];
			m_pTail[i]->m_pPrev=m_pHead[i];
		}
		m_bShow=true;
	}
	virtual ~GLayer()
	{
		GLayerObject*pTemp;
		for(int i=0;i<MAX_LEVEL;i++)
		{
			while(m_pHead[i])
			{
				pTemp=m_pHead[i];
				m_pHead[i]=m_pHead[i]->m_pNext;
				delete pTemp;
			}
			m_pTail[i]=NULL;
		}
	}
private:
	inline void AddObject(GLayerObject*pObj)
	{
		pObj->m_pPrev=m_pTail[pObj->m_nLevel]->m_pPrev;
		m_pTail[pObj->m_nLevel]->m_pPrev->m_pNext=pObj;
		m_pTail[pObj->m_nLevel]->m_pPrev=pObj;
		pObj->m_pNext=m_pTail[pObj->m_nLevel];
	}
	inline void ShowLayer(bool bShow)
	{
		m_bShow=bShow;
	}
	inline bool IsShow()const
	{
		return m_bShow;
	}
private:
	GLayerObject	*m_pHead[MAX_LEVEL];
	GLayerObject	*m_pTail[MAX_LEVEL];
	bool			m_bShow;
};
class GLayerManager
{
public:
	GLayerManager(){}
	virtual ~GLayerManager(){}
	
	inline void AddObject(GLayerObject*pObj,int nLayer)
	{
		assert(pObj);
		assert(nLayer>=0 && nLayer<MAX_LAYER);
		m_Layer[nLayer].AddObject(pObj);
	}
	inline void EnableLayer(int nLayer,bool bEnable)
	{
		assert(nLayer>=0 && nLayer<MAX_LAYER);
		m_Layer[nLayer].ShowLayer(bEnable);
	}
	inline bool IsLayerEnabled(int nLayer)
	{
		assert(nLayer>=0 && nLayer<MAX_LAYER);
		return m_Layer[nLayer].IsShow();
	}
	inline void RenderToScreen(GScreen*pScreen)
	{
		GLayerObject*pObj;
		GLayerObject*pTemp;
		for(int i=0;i<MAX_LAYER;i++)
		{
			if(!m_Layer[i].IsShow())
				continue;
			for(int j=0;j<MAX_LAYER;j++)
			{
				pObj=m_Layer[i].m_pHead[j]->m_pNext;
				while(pObj!=m_Layer[i].m_pTail[j])
				{
					pTemp=pObj->m_pNext;
					pObj->DrawToScreen(pScreen);
					pObj=pTemp;
				}
			}
		}
	}
private:
	GLayer			m_Layer[MAX_LAYER];
};
#endif