gssurface.h

连连看这个游戏都玩过吧

    // DxSurface.h: interface for the CDxSurface class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_DXSURFACE_H__EDD923B5_BFEA_4EE9_92BB_D34EC9F72AB7__INCLUDED_)
#define AFX_DXSURFACE_H__EDD923B5_BFEA_4EE9_92BB_D34EC9F72AB7__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


class GSLIB_API CDxSurface  
{
	friend	CGsEngine;
	friend  CGsSurface;
	friend  CGsTexture;
	friend  CGsTextureGroup;

public:
	HRESULT ChangeFormat(DXSF format);
	HRESULT DrawText( HFONT hfont, LPCTSTR lpString, GRECT* lpRect, LONG lWidth, LONG lHeight, UINT uFormat,
		              D3DCOLOR crForeground = D3DRGBA(1.0F,1.0F,1.0F,1.0f), D3DCOLOR crBackground = D3DRGBA(0.0F,0.0F,0.0F,0.0F) );
	HRESULT DrawNumber( HFONT hfont, LPCTSTR lpString, GRECT* lpRect, LONG lWidth, LONG lHeight, UINT uFormat,
		              D3DCOLOR crForeground = D3DRGBA(1.0F,1.0F,1.0F,1.0f), D3DCOLOR crBackground = D3DRGBA(0.0F,0.0F,0.0F,0.0F) );
	VOID AdjustBasePoint(GPOINT point);
	HRESULT LoadFromRGBData(BYTE *pData, LONG lWidth, LONG lHeight, BOOL bReverse = FALSE, LONG x=0, LONG y=0);
	HRESULT LoadFromPGMFile(GSFBUF* pfBuf);
	DWORD ConvertColor(D3DCOLOR color);
	CGsEngine*			 GetGsEngine()		{ return m_pEngine; }
    LPDIRECTDRAWSURFACE7 GetDDrawSurface()	{ return m_pdds; }
	DXSF				 GetSurfaceFormat()	{ return m_dxsf; }
	DWORD				 GetColorCount()	{ return m_dwColorCount; }
    virtual DWORD		 GetWidth()			{ return m_ddsd.dwWidth; }
    virtual DWORD        GetHeight()		{ return m_ddsd.dwHeight; }
    virtual GRECT		 GetRect()			{ return GRECT(0,0,m_ddsd.dwWidth,m_ddsd.dwHeight); }
	virtual DWORD		 GetPixelInfo(LONG x, LONG y,
									  BYTE* pAlpha=NULL,
									  BYTE* pRed=NULL,
									  BYTE* pGreen=NULL,
									  BYTE* pBlue=NULL);

	virtual HRESULT Update( DWORD )			{ return S_OK; }		// for animate surface
	virtual HRESULT ReleaseSurface();		//{ return S_OK; }
	virtual HRESULT	RestoreSurface();		//{ return S_OK; }

	// user custom operation
	virtual HRESULT	BeginLock( BYTE* &pDes, LONG &lPitch )=0;
	virtual HRESULT	EndLock()=0;

	HRESULT LoadFromPixmap(PIXMAP *pPixmap, LONG x=0, LONG y=0);

	HRESULT LoadFromDibmap(DIBMAP &dibmap, DWORD x=0, DWORD y=0, BOOL bKey=0);
	HRESULT LoadFromDibmapEx(DIBMAP &dibmap, GRECT* prcSrc=NULL, GRECT* prcDes=NULL, BOOL bKey=0);

	HRESULT LoadFromJpegFile(const char* strFile, PIX24* pCK = NULL, LONG x = 0, LONG y =0);
	HRESULT LoadFromJpegFile(GSFBUF* pfBuf, PIX24* pCK = NULL, LONG x = 0, LONG y =0);
	HRESULT LoadFromGif(LPCSTR strFile, int index, PIX24* pCK = NULL, LONG x = 0, LONG y =0);
	HRESULT LoadFromGifCache(void* ptrGif, int index, PIX24* pCK = NULL, LONG x = 0, LONG y =0);

	// Functions for user operate surface
	HRESULT Blt( int x, int y,
				 CDxSurface* pSrcSurface,
				 GRECT* pSrcRect = NULL, 
				 BOOL bUseColorKey = false );
	HRESULT Blt( GRECT* pDestRect,
				 CDxSurface* pSrcSurface,
				 GRECT* pSrcRect = NULL, 
				 BOOL bUseColorKey = false );
	HRESULT CopySurface(int x, int y, 
						CDxSurface* pSrcSurface, 
						GRECT* pSrcRect = NULL);
    HRESULT DrawBitmap( HBITMAP hBMP, DWORD dwBMPOriginX = 0, DWORD dwBMPOriginY = 0, 
		                DWORD dwBMPWidth = 0, DWORD dwBMPHeight = 0 );
    HRESULT DrawBitmap( const TCHAR* strBMP, DWORD dwDesiredWidth, DWORD dwDesiredHeight );
    HRESULT DrawTextDirect( HFONT hFont, const TCHAR* strText, DWORD dwOriginX, DWORD dwOriginY,
		              COLORREF crForeground = RGB(255,255,255), COLORREF crBackground = RGB(0,0,0) );
	HRESULT DrawTextCenter( HFONT hFont, const TCHAR* strText, 
							DWORD dwOriginX, DWORD dwOriginY, DWORD dwLineLength,
							COLORREF crForeground = RGB(255,255,255), COLORREF crBackground = RGB(0,0,0) );
	HRESULT DrawTextInRect( HFONT hFont, const TCHAR* strText, 
							DWORD dwOriginX, DWORD dwOriginY,
							DWORD dwLineLength, DWORD dwHeight,
							COLORREF crForeground = RGB(255,255,255), COLORREF crBackground = RGB(0,0,0) );

    DWORD   ConvertGDIColor( COLORREF dwGDIColor );

	HRESULT	Clear( DWORD dwColor, LPRECT pRect = NULL );
	HRESULT	RGBClear( COLORREF dwColor, LPRECT pRect = NULL );

	HRESULT BeginDc( HDC &dc );
	HRESULT EndDc( HDC &dc );

    virtual VOID Cleanup();

	VOID SetGsEngine(CGsEngine* pEngine);
				CDxSurface();
				CDxSurface( CGsEngine* pEngine );
				~CDxSurface();
protected:
	virtual HRESULT OnCreate();
    HRESULT Create( DDSURFACEDESC2* pddsd );
    HRESULT Create( LPDIRECTDRAWSURFACE7 pdds );

	VOID	OnDismiss();

	CGsEngine*			 m_pEngine;

	KEY					m_keySource;


	BOOL				 m_isDismiss;
	BOOL				 m_isUseVideoMemory;
	LPDIRECTDRAWSURFACE7 m_pdds;
	DDSURFACEDESC2       m_ddsd;
	DXSF				 m_dxsf;
	DWORD				 m_dwColorCount;

	GPGM*				m_guid_buf;
	int					m_guid_size;

	GPOINT	m_BasePoint;

    int m_nRShiftL, m_nRShiftR;
    int m_nGShiftL, m_nGShiftR;
    int m_nBShiftL, m_nBShiftR;
    int m_nAShiftL, m_nAShiftR;

private:

};




class GSLIB_API CGsSurface : public CDxSurface  
{
	friend	CGsEngine;

    BOOL	m_bColorKeyed;
	DWORD	m_dwKeyColor;

	BOOL	m_bUseVideoMem;

public:
	HRESULT CreateFromJPEG(const char* strFile);
	BOOL	SetStreamSource( const char* strSource );
	HRESULT CreateEx(int width, int height, BOOL bUseVideoMem = false);
	HRESULT CreateEx(PIXMAP const& pixmap, BOOL bUseVideoMem = false);

	HRESULT CreateFromBitmap( const TCHAR* strBMP, DWORD dwDesiredWidth = 0, DWORD dwDesiredHeight = 0, BOOL bUseVideoMem = false, DWORD KeyColor=0xffffffff );

	virtual VOID ReleaseObjects();
	virtual HRESULT RestoreObjects();
	// user custom operation
	virtual HRESULT	BeginLock( BYTE* &pDes, LONG &lPitch );
	virtual HRESULT	EndLock();


    HRESULT SetColorKey( COLORREF dwColorKey );
    DWORD   ConvertGDIColor( COLORREF dwGDIColor );
	//HRESULT DrawRect(GRECT const& rect, COLORREF color, BOOL bFill);
	//HRESULT DrawPolygon(GPOINT* ppoint, COLORREF 


	CGsSurface( CGsEngine* pEngine=NULL );
	virtual ~CGsSurface();

};




class GSLIB_API CGsTexture : public CGsSurface  
{
	friend	CGsEngine;

protected:
	int					m_nUser;
	DWORD				 m_width;
	DWORD				 m_height;
	BOOL				m_isTexture;
	DWORD	m_dwNumMipMaps;

	//m_is_use_cache=true 时才使用，这里内存缓冲
	union
	{
		char*				m_cache_memory;
		struct
		{
			void*				m_link_cache_gif;	//危险指针+_+
			int					m_cache_pos;
		};
	};
	FFT					m_cache_fft;
	int					m_mode_cache;

public:
	VOID ClearCache();
	HRESULT UpdateFromCache();
	void SetUseCache(int use_cache_mode);
	BOOL	IsUseCache()	{return m_mode_cache>0;}
	HRESULT CreateShare(CGsTexture* pTexture);
	HRESULT LoadFromSurface(GRECT* rcDest, CDxSurface* pSurface, GRECT* rcSrc);
	BOOL	IsTexture()		{return m_isTexture;} 
	HRESULT LoadFromMemory(char* pMem, D3DCOLOR crEdge=D3DRGBA(0.0f, 0.0f, 0.0f, 0.0f));
	LPDIRECTDRAWSURFACE7 GetTexture();
	BOOL SetStreamSource( const char* strSource, int use_cache_mode );
	int Release();
	int AddUser();
	DWORD				 GetWidthEx()		{ return m_width; }
	DWORD				 GetHeightEx()		{ return m_height; }
	VOID CreateVirtual(LONG width, LONG height, LONG baseX=0, LONG baseY=0);
	HRESULT CreateEx( DWORD width, DWORD height, DXSF dxsf=D3DX_SF_A8R8G8B8, DWORD dwNumMipMaps=0 );
	HRESULT CreateFromFile( const TCHAR* strFile, DWORD width=0, DWORD height=0, DXSF dxsf=D3DX_SF_A8R8G8B8, DWORD dwNumMipMaps=0 );
	HRESULT CreateFromFileEx( const TCHAR* strFile, PIX24* pCK=NULL, DXSF dxsf=D3DX_SF_A8R8G8B8, DWORD dwNumMipMaps=0 );

	BOOL CreateFromTGA(const char* strTGA, float fScale = 0.0f, DXSF dxsf=D3DX_SF_A8R8G8B8, DWORD dwNumMipMaps=0 );
	BOOL CreateFromPixmap(PIXMAP *pPixmap, float fScale = 0.0f, DXSF dxsf=D3DX_SF_A8R8G8B8, DWORD dwNumMipMaps=0 );

	HRESULT Import( const TCHAR* strFile );
	HRESULT Import( GSFBUF &gsbuf );
	DWORD	Export( const TCHAR* strFile, BOOL bCompress = false );
	DWORD	Export( GSFBUF &gsbuf, BOOL bCompress = false );


	virtual VOID ReleaseObjects();
	virtual HRESULT RestoreObjects();
	// user custom operation
	virtual HRESULT	BeginLock( BYTE* &pDes, LONG &lPitch );
	virtual HRESULT	EndLock();


	VOID	SetBasePoint(GPOINT BasePoint)	{ m_BasePoint = BasePoint; }
	GPOINT	GetBasePoint()					{ return m_BasePoint; }

    virtual VOID Cleanup();

	CGsTexture( CGsEngine* pEngine=NULL );
	virtual ~CGsTexture();

public:
};


#define		TXG_FLAG_SHADOW		0x00000001

class GSLIB_API CGsTextureGroup  
{
	friend CGsEngine;
	BOOL				m_bLoadAll;
	FFT					m_source_fft;

	int					m_nUser;
	int					m_nRef_in_use;
	DWORD				m_dwNumTeam;
	float				m_fBaseAngle;
	CGsEngine*			m_pEngine;
	KEY					m_keySource;

	DWORD				m_default_delay;
	DWORD				m_tick_last_use;
	FLAG				m_flag;

	DWORD				m_cache_size;
	std::list<int>		m_cache_indices;
	void*				m_extern_cache_data;	//gif: <CGif98a*>
	std::vector<CGsTexture*>	m_apTexture;
public:
	GPOINT				m_base_point;
	CGsTexture*		GetTexture( int index );
	void*			GetExternCacheData()	{return m_extern_cache_data;}

	LPCSTR			GetSourceName()	{return m_keySource.c_str();}

	FFT				GetSourceFFT()	{return m_source_fft;}
	GPOINT			GetBasePoint()	{return m_base_point;}

	VOID			SetDefaultDelay(DWORD delay)	{m_default_delay = delay;}
	DWORD			GetDefaultDelay()			{return m_default_delay;}
	VOID			SetCacheSize(DWORD size=0);//	{m_cache_size	= size;}
	DWORD			GetCacheSize()				{return m_cache_size;}
	
	FLAG			GetFlag()				{return m_flag;}
	VOID			SetFlag(FLAG flag)		{m_flag = flag;}
	VOID			AddFlag(FLAG flag)		{m_flag |= flag;}
	VOID			ClearFlag(FLAG flag)	{m_flag &= !flag;}
	BOOL			TestFlag(FLAG flag)		{return m_flag&flag;}

	int				GetNumTexture()			{ return m_apTexture.size(); }
	BOOL			SetStreamSource( const char* strSource, BOOL bLoadAll = false );

	HRESULT			Import( const TCHAR* strFile, BOOL bLoadAll = false );
	HRESULT			Import( GSFBUF& gsbuf, BOOL bLoadAll = false );

	DWORD			Export( const TCHAR* strFile, BOOL bCompress );
	DWORD			Export( GSFBUF& gsbuf, BOOL bCompress = false );

public:
	CGsTexture* GetPreTexture(int index);
	BOOL LoadFromGif(LPCSTR strFile);
	int SetCurrentUse(BOOL use=TRUE);
	VOID ClearCache();
	BOOL SaveHeader();
	BOOL LoadFromPGG(const char* strFile);
	HRESULT RestoreObjects();
	int AddUser();
	virtual int Release();
	VOID ReleaseObjects();
	CGsTexture*		InsertTexture( int insert_pos=-1 );
	BOOL			DeleteTexture( int delete_pos );
	BOOL			SwapTexture( int pos1, int pos2 );

	VOID			SetTeam(DWORD nTeam)			{ m_dwNumTeam	= nTeam; }
	DWORD			GetTeam()						{ return m_dwNumTeam; }
	VOID			SetBaseAngle(float fAngle)		{ m_fBaseAngle	= fAngle; }
	float			GetBaseAngle()					{ return m_fBaseAngle; }
	VOID			SetBasePoint(LONG x, LONG y);

	VOID			Cleanup();

	CGsTextureGroup( CGsEngine* pEngine, const char* strSource, BOOL bLoadAll = false );
	CGsTextureGroup( CGsEngine* pEngine );
	virtual ~CGsTextureGroup();

protected:
	virtual			VOID OnInitialize()			{ return; }

};



#endif // !defined(AFX_DXSURFACE_H__EDD923B5_BFEA_4EE9_92BB_D34EC9F72AB7__INCLUDED_)