Work/ddraw/SFCDESC.HPP

#ifndef _DDRAW_SURFACEDESCRIPTION_HPP_
#define _DDRAW_SURFACEDESCRIPTION_HPP_
#ifndef _DDRAW_DDRAW_HPP_
#include <ddraw/ddraw.hpp>
#endif
#ifndef _DDRAW_SURFACECAPABILITIES_HPP_
#include <ddraw/sfccaps.hpp>
#endif

class SurfaceDescription : private DDSURFACEDESC2
{
public:
enum SurfaceFlags{Capabilities=DDSD_CAPS,Height=DDSD_HEIGHT,Width=DDSD_WIDTH,Pitch=DDSD_PITCH,
      BackBufferCount=DDSD_BACKBUFFERCOUNT,ZBufferBitDepth=DDSD_ZBUFFERBITDEPTH,
			AlphaBitDepth=DDSD_ALPHABITDEPTH,Surface=DDSD_LPSURFACE,PixelFormat=DDSD_PIXELFORMAT,
			CKDestinationOverlay=DDSD_CKDESTOVERLAY,CKSourceOverlay=DDSD_CKSRCOVERLAY,
			CKSourceBlt=DDSD_CKSRCBLT,MipMapCount=DDSD_MIPMAPCOUNT,RefreshRate=DDSD_REFRESHRATE,
			LinearSize=DDSD_LINEARSIZE,TextureStage=DDSD_TEXTURESTAGE,All=DDSD_ALL};
  SurfaceDescription(void);
	SurfaceDescription(const SurfaceDescription &someSurfaceDescription);
  SurfaceDescription(const DDSURFACEDESC2 &someDDSURFACEDESC2);
	virtual ~SurfaceDescription();
	SurfaceDescription &operator=(const SurfaceDescription &someSurfaceDescription);
	SurfaceDescription &operator=(const DDSURFACEDESC2 &someDDSURFDESC2);
	DWORD flags(void)const;
	void flags(DWORD flags);
	DWORD height(void)const;
	void height(DWORD height);
	DWORD width(void)const;
	void width(DWORD width);
	LONG lPitch(void)const;
	void lPitch(LONG lPitch);
	DWORD linearSize(void)const;
	void linearSize(DWORD linearSize);
	DWORD backBufferCount(void)const;
	void backBufferCount(DWORD backBufferCount);
	DWORD mipMapCount(void)const;
	void mipMapCount(DWORD mipMapCount);
	DWORD refreshRate(void)const;
	void refreshRate(DWORD refreshRate);
	DWORD alphaBitDepth(void)const;
	void alphaBitDepth(DWORD alphaBitDepth);
	LPVOID ptrSurface(void);
	void ptrSurface(LPVOID pSurface);
	const DDCOLORKEY &ckDestOverlay(void)const;
	void ckDestOverlay(const DDCOLORKEY &ckDestOverlay);
	const DDCOLORKEY &ckDestBlt(void)const;
	void ckDestBlt(const DDCOLORKEY &ckDestBlt);
	const DDCOLORKEY &ckSrcOverlay(void)const;
	void ckSrcOverlay(const DDCOLORKEY &ckSrcOverlay);
	const DDCOLORKEY &ckSrcBlt(void)const;
	void ckSrcBlt(const DDCOLORKEY &ckSrcBlt);
	const DDPIXELFORMAT &pixelFormat(void)const;
	void pixelFormat(const DDPIXELFORMAT &pixelFormat);
	SurfaceCapabilities surfaceCapabilities(void)const;
	void surfaceCapabilities(const SurfaceCapabilities &surfaceCapabilities);
  DWORD textureStage(void)const;
	void textureStage(DWORD textureStage);
	DDSURFACEDESC2 &getDDSURFACEDESC2(void);
private:
  void zeroInit(void);
};

inline
SurfaceDescription::SurfaceDescription(void)
{
  zeroInit();
}

inline
SurfaceDescription::SurfaceDescription(const SurfaceDescription &someSurfaceDescription)
{
  *this=someSurfaceDescription;
}

inline
SurfaceDescription::SurfaceDescription(const DDSURFACEDESC2 &someDDSURFACEDESC2)
{
  *this=someDDSURFACEDESC2;
}

inline
SurfaceDescription::~SurfaceDescription()
{
}

inline
SurfaceDescription &SurfaceDescription::operator=(const SurfaceDescription &someSurfaceDescription)
{
  ::memcpy(&getDDSURFACEDESC2(),&((SurfaceDescription&)someSurfaceDescription).getDDSURFACEDESC2(),sizeof(DDSURFACEDESC2));
	return *this;
}

inline
SurfaceDescription &SurfaceDescription::operator=(const DDSURFACEDESC2 &someDDSURFACEDESC2)
{
  ::memcpy(&getDDSURFACEDESC2(),&someDDSURFACEDESC2,sizeof(DDSURFACEDESC2));
	DDSURFACEDESC2::dwSize=sizeof(DDSURFACEDESC2);
	return *this;
}

inline
DWORD SurfaceDescription::flags(void)const
{
  return DDSURFACEDESC2::dwFlags;
}

inline
void SurfaceDescription::flags(DWORD flags)
{
  DDSURFACEDESC2::dwFlags=flags;
}

inline
DWORD SurfaceDescription::height(void)const
{
  return DDSURFACEDESC2::dwHeight;
}

inline
void SurfaceDescription::height(DWORD height)
{
  DDSURFACEDESC2::dwHeight=height;
}

inline
DWORD SurfaceDescription::width(void)const
{
  return DDSURFACEDESC2::dwWidth;
}

inline
void SurfaceDescription::width(DWORD width)
{
  DDSURFACEDESC2::dwWidth=width;
}

inline
LONG SurfaceDescription::lPitch(void)const
{
  return DDSURFACEDESC2::lPitch;
}

inline
void SurfaceDescription::lPitch(LONG lPitch)
{
  DDSURFACEDESC2::lPitch=lPitch;
}

inline
DWORD SurfaceDescription::linearSize(void)const
{
  return DDSURFACEDESC2::dwLinearSize;
}

inline
void SurfaceDescription::linearSize(DWORD linearSize)
{
  DDSURFACEDESC2::dwLinearSize=linearSize;
}

inline
DWORD SurfaceDescription::backBufferCount(void)const
{
  return DDSURFACEDESC2::dwBackBufferCount;
}

inline
void SurfaceDescription::backBufferCount(DWORD backBufferCount)
{
  DDSURFACEDESC2::dwBackBufferCount=backBufferCount;
}

inline
DWORD SurfaceDescription::mipMapCount(void)const
{
  return DDSURFACEDESC2::dwMipMapCount;
}

inline
void SurfaceDescription::mipMapCount(DWORD mipMapCount)
{
  DDSURFACEDESC2::dwMipMapCount=mipMapCount;
}

inline
DWORD SurfaceDescription::refreshRate(void)const
{
  return DDSURFACEDESC2::dwRefreshRate;
}

inline
void SurfaceDescription::refreshRate(DWORD refreshRate)
{
  DDSURFACEDESC2::dwRefreshRate=refreshRate;
}

inline
DWORD SurfaceDescription::alphaBitDepth(void)const
{
  return DDSURFACEDESC2::dwAlphaBitDepth;
}

inline
void SurfaceDescription::alphaBitDepth(DWORD alphaBitDepth)
{
  DDSURFACEDESC2::dwAlphaBitDepth=alphaBitDepth;
}

inline
LPVOID SurfaceDescription::ptrSurface(void)
{
  return DDSURFACEDESC2::lpSurface;
}

inline
void SurfaceDescription::ptrSurface(LPVOID pSurface)
{
  DDSURFACEDESC2::lpSurface=pSurface;
}

inline
const DDCOLORKEY &SurfaceDescription::ckDestOverlay(void)const
{
  return DDSURFACEDESC2::ddckCKDestOverlay;
}

inline
void SurfaceDescription::ckDestOverlay(const DDCOLORKEY &ckDestOverlay)
{
  DDSURFACEDESC2::ddckCKDestOverlay=ckDestOverlay;
}

inline
const DDCOLORKEY &SurfaceDescription::ckDestBlt(void)const
{
  return DDSURFACEDESC2::ddckCKDestBlt;
}

inline
void SurfaceDescription::ckDestBlt(const DDCOLORKEY &ckDestBlt)
{
  DDSURFACEDESC2::ddckCKDestBlt=ckDestBlt;
}

inline
const DDCOLORKEY &SurfaceDescription::ckSrcOverlay(void)const
{
  return DDSURFACEDESC2::ddckCKSrcOverlay;
}

inline
void SurfaceDescription::ckSrcOverlay(const DDCOLORKEY &ckSrcOverlay)
{
  DDSURFACEDESC2::ddckCKSrcOverlay=ckSrcOverlay;
}

inline
const DDCOLORKEY &SurfaceDescription::ckSrcBlt(void)const
{
  return DDSURFACEDESC2::ddckCKSrcBlt;
}

inline
void SurfaceDescription::ckSrcBlt(const DDCOLORKEY &ckSrcBlt)
{
  DDSURFACEDESC2::ddckCKSrcBlt=ckSrcBlt;
}

inline
const DDPIXELFORMAT &SurfaceDescription::pixelFormat(void)const
{
  return DDSURFACEDESC2::ddpfPixelFormat;
}

inline
void SurfaceDescription::pixelFormat(const DDPIXELFORMAT &pixelFormat)
{
  DDSURFACEDESC2::ddpfPixelFormat=pixelFormat;
}

inline
SurfaceCapabilities SurfaceDescription::surfaceCapabilities(void)const
{
  return SurfaceCapabilities(DDSURFACEDESC2::ddsCaps);
}

inline
void SurfaceDescription::surfaceCapabilities(const SurfaceCapabilities &surfaceCapabilities)
{
  DDSURFACEDESC2::ddsCaps=((SurfaceCapabilities&)surfaceCapabilities).getDDSCAPS2();
}

inline
DWORD SurfaceDescription::textureStage(void)const
{
  return DDSURFACEDESC2::dwTextureStage;
}

inline
void SurfaceDescription::textureStage(DWORD textureStage)
{
  DDSURFACEDESC2::dwTextureStage;
}

inline
DDSURFACEDESC2 &SurfaceDescription::getDDSURFACEDESC2(void)
{
  return (DDSURFACEDESC2&)*this;
}

inline
void SurfaceDescription::zeroInit(void)
{
  ::memset(&getDDSURFACEDESC2(),0,sizeof(DDSURFACEDESC2));
  DDSURFACEDESC2::dwSize=sizeof(DDSURFACEDESC2);
}
#endif