--- /dev/null
+#include "stdafx.h"
+#include "FDKError.h"
+#include "CSurface.h"
+#include "LoadPNG.h"
+#include "LoadJPEG.h"
+#include "Debug.h"
+
+namespace FDK {
+ namespace Graphics {
+
+CSurface::CSurface()
+{
+ this->pSurface = NULL;
+ this->nAlphaConst = 255;
+ this->dwWidth = 0;
+ this->dwHeight = 0;
+ this->place = LOADTO_VIDEO_OR_SYSTEM;
+ this->bColorKeyEnable = false;
+ this->dwColorKey = 0xFF000000;
+ this->strSurfaceName.clear();
+ this->strFileName.clear();
+ this->lpResourceName = NULL;
+ this->lpResourceType = NULL;
+ this->pData = NULL;
+ this->dwDataSize = 0;
+
+ ::ZeroMemory( &this->ddpfReference, sizeof( DDPIXELFORMAT ) );
+}
+
+CSurface::~CSurface()
+{
+ SAFE_RELEASE( this->pSurface );
+}
+
+void CSurface::InitDeviceObjects( LPCTSTR name, DWORD width, DWORD height, LOADPLACE place, LPDDPIXELFORMAT pFormat )
+{
+ this->InitParameters( name, NULL, NULL, NULL, NULL, 0, width, height, place, pFormat );
+}
+
+void CSurface::InitDeviceObjectsFromFile( LPCTSTR name, LPCTSTR filename, DWORD width, DWORD height, LOADPLACE place, LPDDPIXELFORMAT pFormat )
+{
+ this->InitParameters( name, filename, NULL, NULL, NULL, 0, width, height, place, pFormat );
+}
+
+void CSurface::InitDeviceObjectsFromMemory( LPCTSTR name, BYTE* pData, DWORD dwDataSize, DWORD width, DWORD height, LOADPLACE place, LPDDPIXELFORMAT pFormat )
+{
+ this->InitParameters( name, NULL, NULL, NULL, pData, dwDataSize, width, height, place, pFormat );
+}
+
+void CSurface::InitDeviceObjectsFromResource( LPCTSTR name, LPCTSTR lpResourceName, LPCTSTR lpResourceType, DWORD width, DWORD height, LOADPLACE place, LPDDPIXELFORMAT pFormat )
+{
+ this->InitParameters( name, NULL, lpResourceName, lpResourceType, NULL, 0, width, height, place, pFormat );
+}
+
+void CSurface::InitParameters( LPCTSTR name, LPCTSTR fname, LPCTSTR lpResourceName, LPCTSTR lpResourceType, BYTE* pData, DWORD dwDataSize, DWORD width, DWORD height, LOADPLACE place, LPDDPIXELFORMAT pFormat )
+{
+ // \96¼\91O
+ this->strSurfaceName.clear();
+ if( name )
+ this->strSurfaceName = name;
+
+ this->strFileName.clear();
+ if( fname )
+ this->strFileName = fname;
+
+ // \83\8a\83\\81[\83X
+ this->lpResourceName = lpResourceName;
+ this->lpResourceType = lpResourceType;
+
+ // \83f\81[\83^\83|\83C\83\93\83^\81A\83f\81[\83^\83T\83C\83Y
+ this->pData = pData;
+ this->dwDataSize = dwDataSize;
+
+ // \83T\83C\83Y
+ this->dwWidth = width;
+ this->dwHeight = height;
+
+ // \94z\92u\8fê\8f\8a
+ this->place = place;
+
+ // \83s\83N\83Z\83\8b\83t\83H\81[\83}\83b\83g
+ if( pFormat != NULL )
+ this->ddpfReference = *pFormat;
+ else
+ this->ddpfReference.dwSize = 0; // \96³\8cø\82Ì\82µ\82é\82µ
+
+ // \82»\82Ì\91¼\81i\83f\83t\83H\83\8b\83g\92l\81j
+ this->nAlphaConst = 255;
+ this->bColorKeyEnable = false;
+ this->dwColorKey = 0xFF000000;
+
+ SAFE_RELEASE( this->pSurface );
+}
+
+HRESULT CSurface::RestoreDeviceObjects()
+{
+ HRESULT hr = D3D_OK;
+
+ // (1) \8ew\92è\83t\83@\83C\83\8b\82©\82ç\82Ì\90¶\90¬( BMP, PNG, JPEG )
+ if( ! this->strFileName.empty() )
+ hr = this->RestoreDeviceObjectsFromFile();
+
+ // (2) \83\81\83\82\83\8a\93à\83t\83@\83C\83\8b\82©\82ç\82Ì\90¶\90¬( PNG \82Ì\82Ý )
+ else if( this->pData != NULL && this->dwDataSize > 0 )
+ hr = this->RestoreDeviceObjectsFromFileInMemory();
+
+ // (3) \83\8a\83\\81[\83X\82©\82ç\82Ì\90¶\90¬( PNG \82Ì\82Ý )
+ else if( this->lpResourceName != NULL && this->lpResourceType != NULL )
+ hr = this->RestoreDeviceObjectsFromResource();
+
+ // (4) \8bó\90¶\90¬
+ else if( FAILED( hr = this->Create() ) )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82Ì\8dì\90¬\82É\8e¸\94s;
+
+ return hr;
+}
+
+HRESULT CSurface::RestoreDeviceObjectsFromResource()
+{
+ HMODULE hModule = (HMODULE)::GetClassLongPtr( CD3DApplication::hWnd, GCL_HMODULE );
+
+ HRSRC hSrc = ::FindResource( hModule, this->lpResourceName, this->lpResourceType );
+ if( ! hSrc )
+ return FDKERR_\83t\83@\83C\83\8b\82Ì\93Ç\82Ý\8d\9e\82Ý\8e¸\94s;
+
+ HGLOBAL hPNG = LoadResource( hModule, hSrc );
+ if( ! hPNG )
+ return FDKERR_\83t\83@\83C\83\8b\82Ì\93Ç\82Ý\8d\9e\82Ý\8e¸\94s;
+
+ this->dwDataSize = SizeofResource( hModule, hSrc );
+ if( this->dwDataSize == 0 )
+ return FDKERR_\83t\83@\83C\83\8b\82Ì\93Ç\82Ý\8d\9e\82Ý\8e¸\94s;
+
+ this->pData = (BYTE*) LockResource( hPNG );
+ if( ! this->pData )
+ return FDKERR_\83t\83@\83C\83\8b\82Ì\93Ç\82Ý\8d\9e\82Ý\8e¸\94s;
+
+ return this->RestoreDeviceObjectsFromFileInMemory();
+}
+
+HRESULT CSurface::RestoreDeviceObjectsFromFileInMemory()
+{
+ HRESULT hr = S_OK;
+
+ SAFE_RELEASE( this->pSurface );
+
+ // \8fó\91Ô\83`\83F\83b\83N
+ if( ! CD3DApplication::pDD )
+ return FDKERR_DirectDraw\82ªNULL;
+
+ // \83\81\83\82\83\8a\83C\83\81\81[\83W\83t\83@\83C\83\8b\82©\82ç\82Ì\90¶\90¬
+ if( this->pData && this->dwDataSize > 0 )
+ {
+ BITMAPINFO* pbinfo = NULL;
+ BYTE* pbdata = NULL;
+
+ // PNG \82©\82ç\82Ì\90¶\90¬
+ if( LoadPNGtoDIB( this->pData, this->dwDataSize, &pbinfo, &pbdata ) )
+ {
+ hr = RestoreFromBitmap( pbinfo, pbdata );
+ SAFE_FREE( pbinfo );
+ SAFE_FREE( pbdata );
+ }
+ else
+ hr = FDKERR_DIB\82Ì\8dì\90¬\82É\8e¸\94s;
+ }
+ return hr;
+}
+
+HRESULT CSurface::RestoreDeviceObjectsFromFile()
+{
+ HRESULT hr;
+
+ SAFE_RELEASE( this->pSurface );
+
+ // \8fó\91Ô\83`\83F\83b\83N
+ if( ! CD3DApplication::pDD )
+ return FDKERR_DirectDraw\82ªNULL;
+
+ // \83t\83@\83C\83\8b\82©\82ç\82Ì\89æ\91\9c\93Ç\82Ý\8d\9e\82Ý;
+ // BMP ... LoadImage() \82ÅBITMAP\83n\83\93\83h\83\8b\82ð\8dì\90¬\82µ\82Ä RestoreFromBitmap()
+ // JPG ... LoadJPEG() \82Å BITMAPINFO \82ð\8dì\90¬\82µ\82Ä\81@\81@\81@\81@\81V
+ // PNG ... LoadPNG() \82Å BITMAPINFO \82ð\8dì\90¬\82µ\82Ä\81@\81@\81@\81@\81V
+ if( ! this->strFileName.empty() )
+ {
+ //-----------------------------
+ // (A) \83r\83b\83g\83}\83b\83v\82Ì\8fê\8d\87
+ HBITMAP hBitmap;
+ if( ( hBitmap = (HBITMAP) ::LoadImage( NULL, this->strFileName.c_str(), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE ) ) != NULL )
+ {
+ hr = RestoreFromBitmap( hBitmap );
+ DeleteObject( hBitmap );
+ return hr;
+ }
+
+ //-----------------------------
+ // (B) \82»\82Ì\91¼\82Ì\8fê\8d\87 \81¨ \83t\83@\83C\83\8b\82ð\83I\81[\83v\83\93\82µ\82Ä\8eí\95Ê\83`\83F\83b\83N
+ BITMAPINFO* pbinfo = NULL;
+ BYTE* pbdata = NULL;
+
+ FILE* fp;
+ if( _tfopen_s( &fp, this->strFileName.c_str(), _T("rb") ) != 0 )
+ return FDKERR_\83t\83@\83C\83\8b\82Ì\93Ç\82Ý\8d\9e\82Ý\8e¸\94s;
+
+ //-----------------------------
+ // (B1) JPEG \82Ì\8fê\8d\87
+ int h = fgetc( fp ) * 256 + fgetc( fp );
+ fseek( fp, 0, SEEK_SET );
+ if( h == 0xFFD8 && LoadJPEG( fp, &pbinfo, &pbdata ) != 0 )
+ {
+ hr = RestoreFromBitmap( pbinfo, pbdata );
+ SAFE_FREE( pbinfo );
+ SAFE_FREE( pbdata );
+ fclose( fp );
+ return hr;
+ }
+ else
+ {
+ SAFE_FREE( pbinfo );
+ SAFE_FREE( pbdata );
+ }
+
+ //-----------------------------
+ // (B2) PNG \82Ì\8fê\8d\87
+ fclose( fp );
+ if( LoadPNGtoDIB( this->strFileName.c_str(), &pbinfo, &pbdata ) )
+ {
+ hr = RestoreFromBitmap( pbinfo, pbdata );
+ SAFE_FREE( pbinfo );
+ SAFE_FREE( pbdata );
+ return hr;
+ }
+ else
+ {
+ SAFE_FREE( pbinfo );
+ SAFE_FREE( pbdata );
+ }
+ }
+ else
+ return FDKERR_\83t\83@\83C\83\8b\82Ì\93Ç\82Ý\8d\9e\82Ý\8e¸\94s; // \83t\83@\83C\83\8b\96¼\82Ì\8ew\92è\82ª\82È\82¢
+
+ return S_OK;
+}
+
+HRESULT CSurface::RestoreFromBitmap( HBITMAP hBitmap )
+{
+ HRESULT hr;
+
+ // Bitmap \8fî\95ñ\82Ì\8eæ\93¾ \81¨ bm
+ BITMAP bm;
+ ::GetObject( hBitmap, sizeof( BITMAP ), &bm );
+
+ // \83\81\83\82\83\8aDC \82Ì\8dì\90¬ \81¨ hBDC
+ HDC hBDC;
+ if( ( hBDC = ::CreateCompatibleDC( NULL ) ) == NULL )
+ return FDKERR_DC\82Ì\8eæ\93¾\82É\8e¸\94s;
+
+ // \83T\83C\83Y\92²\90®\81G this->dwWidth, this->dwHeight \82ª\82Æ\82à\82É 0 \82È\82ç\89æ\91\9c\83T\83C\83Y\82É\93\99\82µ\82\82·\82é\81B
+ if( this->dwWidth == 0 && this->dwHeight == 0 )
+ {
+ this->dwWidth = bm.bmWidth;
+ this->dwHeight = bm.bmHeight;
+ }
+
+ // \83T\83C\83Y\82ª\81ithis->dwWidth, this->dwHeight\81j\82Å\82 \82é\8bó\82Ì\83T\81[\83t\83F\83C\83X\82Ì\8dì\90¬
+ if( FAILED( hr = Create() ) )
+ {
+ ::DeleteDC( hBDC );
+ return hr; // \8e¸\94s
+ }
+
+ // \83T\81[\83t\83F\83C\83X\82Ì DC \82Ì\8eæ\93¾ \81¨ hSDC
+ HDC hSDC;
+ if( FAILED( hr = this->pSurface->GetDC( &hSDC ) ) )
+ {
+ ::DeleteDC( hBDC );
+ return hr; // \8e¸\94s
+ }
+
+ // Bitmap DC \82©\82ç \83T\81[\83t\83F\83C\83XDC \82Ö\89æ\91\9c\82ð\93]\91\97\81G
+ // StretchBlt() \82È\82Ì\82Å\81A\83T\83C\83Y\82ª\88Ù\82È\82é\8fê\8d\87\82Í\83T\81[\83t\83F\83C\83X\82Ì\83T\83C\83Y\82É\8ag\91å\81E\8fk\8f¬\82³\82ê\82é\81B
+ ::SelectObject( hBDC, hBitmap );
+ if( ::StretchBlt(
+ hSDC, 0, 0, this->dwWidth, this->dwHeight, // \93]\91\97\90æ
+ hBDC, 0, 0, bm.bmWidth, bm.bmHeight, // \93]\91\97\8c³
+ SRCCOPY ) == 0 )
+ {
+ this->pSurface->ReleaseDC( hSDC );
+ ::DeleteDC( hBDC );
+ return FDKERR_StretchBlt\82É\8e¸\94s;
+ }
+
+ // \90¬\8c÷\81A\8bA\8aÒ
+ this->pSurface->ReleaseDC( hSDC );
+ ::DeleteDC( hBDC );
+ return S_OK;
+}
+
+HRESULT CSurface::RestoreFromBitmap( BITMAPINFO* pbinfo, BYTE* pbdata )
+{
+ HRESULT hr;
+
+ // \83T\83C\83Y\92²\90®\81G this->dwWidth, this->dwHeight \82ª\82Æ\82à\82É 0 \82È\82ç\89æ\91\9c\83T\83C\83Y\82É\93\99\82µ\82\82·\82é\81B
+ if( this->dwWidth == 0 && this->dwHeight == 0 )
+ {
+ this->dwWidth = pbinfo->bmiHeader.biWidth;
+ this->dwHeight = pbinfo->bmiHeader.biHeight;
+ }
+
+ // \83T\83C\83Y\82ª\81ithis->dwWidth, this->dwHeight\81j\82Å\82 \82é\8bó\82Ì\83T\81[\83t\83F\83C\83X\82Ì\8dì\90¬
+ if( FAILED( hr = Create() ) )
+ return hr; // \8e¸\94s
+
+ // \83T\81[\83t\83F\83C\83X\82Ì DC \82Ì\8eæ\93¾ \81¨ hSDC
+ HDC hSDC;
+ if( FAILED( hr = this->pSurface->GetDC( &hSDC ) ) )
+ return hr; // \8e¸\94s
+
+ // Jpeg DC \82©\82ç \83T\81[\83t\83F\83C\83XDC \82Ö\89æ\91\9c\82ð\93]\91\97\81G
+ // \81@StretchBlt() \82È\82Ì\82Å\81A\83T\83C\83Y\82ª\88Ù\82È\82é\8fê\8d\87\82Í\83T\81[\83t\83F\83C\83X\82Ì\83T\83C\83Y\82É\8ag\91å\81E\8fk\8f¬\82³\82ê\82é\81B
+ if( StretchDIBits(
+ hSDC, // \93]\91\97\90æ DC
+ 0, 0, this->dwWidth, this->dwHeight, // \93]\91\97\90æ\97Ì\88æ
+ 0, 0, pbinfo->bmiHeader.biWidth, pbinfo->bmiHeader.biHeight, // \93]\91\97\8c³\97Ì\88æ
+ (LPVOID) pbdata, pbinfo, // \83r\83b\83g\83}\83b\83v
+ DIB_RGB_COLORS, SRCCOPY ) == GDI_ERROR )
+ {
+ this->pSurface->ReleaseDC( hSDC );
+ return FDKERR_StretchBlt\82É\8e¸\94s;
+ }
+
+ // \90¬\8c÷\81A\8bA\8aÒ
+ this->pSurface->ReleaseDC( hSDC );
+ return S_OK;
+}
+
+HRESULT CSurface::Create()
+{
+ HRESULT hr;
+
+ for( int i = 0; i < 3; i++ ) // 3\92Ê\82è\82Ì\90¶\90¬\82É\92§\90í
+ {
+ DDSURFACEDESC2 ddsd;
+ ::ZeroMemory( &ddsd, sizeof( DDSURFACEDESC2 ) );
+ ddsd.dwSize = sizeof( DDSURFACEDESC2 );
+
+ switch( i )
+ {
+ case 0: // (1) \8ew\92è\82³\82ê\82½PIXELFRMAT
+ {
+ if( this->ddpfReference.dwSize == 0 )
+ continue;
+ ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
+ ddsd.dwWidth = this->dwWidth;
+ ddsd.dwHeight = this->dwHeight;
+ ddsd.ddpfPixelFormat.dwFlags = this->ddpfReference.dwFlags;
+ ddsd.ddpfPixelFormat.dwFourCC = this->ddpfReference.dwFourCC;
+ ddsd.ddpfPixelFormat.dwRGBBitCount = this->ddpfReference.dwRGBBitCount;
+ ddsd.ddpfPixelFormat.dwRBitMask = this->ddpfReference.dwRBitMask;
+ ddsd.ddpfPixelFormat.dwGBitMask = this->ddpfReference.dwGBitMask;
+ ddsd.ddpfPixelFormat.dwBBitMask = this->ddpfReference.dwBBitMask;
+ ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = this->ddpfReference.dwRGBAlphaBitMask;
+ break;
+ }
+
+ case 1: // (2) \89æ\96Ê\82Æ\93¯\82¶PIXELFORMAT
+ {
+ DDSURFACEDESC2 ddsdscr;
+ ZeroMemory( &ddsdscr, sizeof( DDSURFACEDESC2 ) );
+ ddsdscr.dwSize = sizeof( DDSURFACEDESC2 );
+ CD3DApplication::pDD->GetDisplayMode( &ddsdscr );
+ ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
+ ddsd.dwWidth = this->dwWidth;
+ ddsd.dwHeight = this->dwHeight;
+ ddsd.ddpfPixelFormat.dwFlags = ddsdscr.ddpfPixelFormat.dwFlags;
+ ddsd.ddpfPixelFormat.dwFourCC = ddsdscr.ddpfPixelFormat.dwFourCC;
+ ddsd.ddpfPixelFormat.dwRGBBitCount = ddsdscr.ddpfPixelFormat.dwRGBBitCount;
+ ddsd.ddpfPixelFormat.dwRBitMask = ddsdscr.ddpfPixelFormat.dwRBitMask;
+ ddsd.ddpfPixelFormat.dwGBitMask = ddsdscr.ddpfPixelFormat.dwGBitMask;
+ ddsd.ddpfPixelFormat.dwBBitMask = ddsdscr.ddpfPixelFormat.dwBBitMask;
+ ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = ddsdscr.ddpfPixelFormat.dwRGBAlphaBitMask;
+ break;
+ }
+ case 2: // (3) PIXELFORMAT \82È\82µ
+ ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
+ ddsd.dwWidth = this->dwWidth;
+ ddsd.dwHeight = this->dwHeight;
+ break;
+
+ }
+retry:
+ ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | ( (this->place == LOADTO_SYSTEM) ? DDSCAPS_SYSTEMMEMORY : DDSCAPS_VIDEOMEMORY );
+
+ if( FAILED( hr = CD3DApplication::pDD->CreateSurface( &ddsd, &this->pSurface, NULL ) ) )
+ {
+ if( this->place == LOADTO_VIDEO_OR_SYSTEM ) // LOADTO_VIDEO_OR_SYSTEM \82ª\8ew\92è\82³\82ê\82Ä\82¢\82é\82Æ\82«\82Í\81A
+ {
+ this->place = LOADTO_SYSTEM; // VIDEO \82É\8e¸\94s\82µ\82½\82ç SYSTEM \82Å\8dì\82è\92¼\82·\81B
+ goto retry;
+ }
+ }
+
+ // \8dì\90¬\82É\90¬\8c÷\82µ\82½\82ç\81A\8d\95\82ð\93§\89ß\83L\81[\82É\90Ý\92è\82µ\82Ä\8bA\8aÒ\81B
+ if( SUCCEEDED( hr ) )
+ {
+ this->SetColorKey( /*( CD3DApplication::nBpp == 16 ) ? 0x0000F000 :*/ 0xFF000000 );
+ break;
+ }
+ }
+
+ return hr;
+}
+
+HRESULT CSurface::InvalidateDeviceObjects()
+{
+ SAFE_RELEASE( this->pSurface );
+ return S_OK;
+}
+
+HRESULT CSurface::DeleteDeviceObjects()
+{
+ SAFE_RELEASE( this->pSurface );
+ this->InitParameters( NULL, NULL, NULL, NULL, NULL, 0, 0, 0, LOADTO_SYSTEM, NULL );
+ return S_OK;
+}
+
+void CSurface::SetAlphaConst( int a )
+{
+ if( a < 0 ) a = 0;
+ if( a > 255 ) a = 255;
+ this->nAlphaConst = a;
+}
+
+HRESULT CSurface::SetColorKey()
+{
+ HRESULT hr = S_OK;
+
+ if( ! this->pSurface )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+
+ // \8d¶\8fã\8b÷\82Ì\93_\82Ì\90F\82ð\8eæ\93¾
+ DDSURFACEDESC2 ddsd;
+ ZeroMemory( &ddsd, sizeof(ddsd) );
+ ddsd.dwSize = sizeof(ddsd);
+ if( SUCCEEDED( hr = this->pSurface->Lock( NULL, &ddsd, DDLOCK_WAIT, NULL ) ) )
+ {
+ DWORD dwBits = ddsd.ddpfPixelFormat.dwRGBBitCount;
+ this->dwColorKey = (*(DWORD*)ddsd.lpSurface) & ((dwBits == 16) ? 0x0000FFFF : 0xFFFFFFFF);
+ this->pSurface->Unlock( NULL );
+
+ // \83J\83\89\81[\83L\81[\82Æ\82µ\82Ä\90Ý\92è
+ DDCOLORKEY ddck;
+ ddck.dwColorSpaceLowValue = this->dwColorKey;
+ ddck.dwColorSpaceHighValue = this->dwColorKey;
+ this->pSurface->SetColorKey( DDCKEY_SRCBLT, &ddck );
+ }
+ else
+ return hr;
+
+ return S_OK;
+}
+
+HRESULT CSurface::SetColorKey( DWORD dwColor )
+{
+ if( ! this->pSurface )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+
+ // \83J\83\89\81[\83L\81[\82Æ\82µ\82Ä\90Ý\92è
+ DDCOLORKEY ddck;
+ ddck.dwColorSpaceLowValue = dwColor;
+ ddck.dwColorSpaceHighValue = dwColor;
+ this->pSurface->SetColorKey( DDCKEY_SRCBLT, &ddck );
+ this->dwColorKey = dwColor;
+
+ return S_OK;
+}
+
+HRESULT CSurface::GetDC( HDC *phdc )
+{
+ if( ! this->pSurface )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+ if( ! phdc )
+ return E_INVALIDARG;
+
+ this->LostCheck(); // \83\8d\83X\83g\82µ\82Ä\82¢\82ê\82Î\95\9c\8b\8c\82·\82é
+
+ return this->pSurface->GetDC( phdc );
+}
+
+HRESULT CSurface::ReleaseDC( HDC &phdc )
+{
+ if( ! this->pSurface )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+
+ return this->pSurface->ReleaseDC( phdc );
+}
+
+HRESULT CSurface::Clear( LPRECT prc )
+{
+ if( this->pSurface == NULL )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+
+ this->LostCheck(); // \83\8d\83X\83g\82µ\82Ä\82¢\82ê\82Î\95\9c\8b\8c\82·\82é
+
+ DDBLTFX ddbltfx;
+ ::ZeroMemory( &ddbltfx, sizeof( ddbltfx ) );
+ ddbltfx.dwSize = sizeof( ddbltfx );
+ ddbltfx.dwFillColor = 0;
+ this->pSurface->Blt( prc, NULL, NULL, DDBLT_COLORFILL, &ddbltfx );
+ return S_OK;
+}
+
+DWORD CSurface::GetSurfaceSize()
+{
+ if( ! this->pSurface )
+ return 0;
+
+ this->LostCheck(); // \83\8d\83X\83g\82µ\82Ä\82¢\82ê\82Î\95\9c\8b\8c\82·\82é
+
+ DDSURFACEDESC2 ddsd;
+ ZeroMemory( &ddsd, sizeof( ddsd ) );
+ ddsd.dwSize = sizeof( ddsd );
+ if( FAILED( this->pSurface->GetSurfaceDesc( &ddsd ) ) )
+ return 0;
+
+ DWORD dwSize = 0;
+ for( DWORD y = 0; y < ddsd.dwHeight; y++ )
+ dwSize += ddsd.lPitch;
+
+ return dwSize;
+}
+HRESULT CSurface::Draw( LPDIRECTDRAWSURFACE7 pDest, int x, int y, LPCRECT pSrc )
+{
+ HRESULT hr;
+
+ // \83¿\82ª 255 \96¢\96\9e\82Ì\8fê\8d\87\82Í\81A\83\\83t\83g\83E\83F\83A\82Å\8d\87\90¬\95`\89æ\82·\82é\81B
+ if( this->nAlphaConst != 255 )
+ return this->BlendDraw( pDest, x, y, pSrc );
+
+ if( ! this->pSurface || ! pDest )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+
+ this->LostCheck(); // \83\8d\83X\83g\82µ\82Ä\82¢\82ê\82Î\95\9c\8b\8c\82·\82é
+
+ // \93]\91\97\8c³\97Ì\88æ(rcSrc)\82Ì\8eZ\8fo
+ RECT rcSrc = { 0, 0, this->dwWidth, this->dwHeight };
+ if( pSrc )
+ rcSrc = *pSrc;
+
+ // \93]\91\97\90æ\97Ì\88æ(rcDest)\82Ì\8eZ\8fo
+ RECT rcDest;
+ DDSURFACEDESC2 ddsd;
+ ::ZeroMemory( &ddsd, sizeof( ddsd ) );
+ ddsd.dwSize = sizeof( ddsd );
+ pDest->GetSurfaceDesc( &ddsd );
+ ::SetRect( &rcDest, 0, 0, ddsd.dwWidth, ddsd.dwHeight );
+
+ // \83N\83\8a\83b\83s\83\93\83O
+ int nSrcWidth = rcSrc.right - rcSrc.left;
+ int nSrcHeight = rcSrc.bottom - rcSrc.top;
+ int nDestWidth = rcDest.right - rcDest.left;
+ int nDestHeight = rcDest.bottom - rcDest.top;
+ if( ( x + nSrcWidth ) < 0 || ( y + nSrcHeight ) < 0 || x > nDestWidth || y > nDestHeight ) return S_OK;
+ if( x < 0 ) { rcSrc.left += (-x); x = 0; }
+ if( y < 0 ) { rcSrc.top += (-y); y = 0; }
+ if( x + nSrcWidth > nDestWidth ) { rcSrc.right -= x + nSrcWidth - nDestWidth; }
+ if( y + nSrcHeight > nDestHeight ) { rcSrc.bottom -= y + nSrcHeight - nDestHeight; }
+ if( rcSrc.right - rcSrc.left <= 0 || rcSrc.bottom - rcSrc.top <= 0 ) return S_OK;
+
+ // \95`\89æ
+ SetRect( &rcDest, x, y, x+rcSrc.right-rcSrc.left, y+rcSrc.bottom-rcSrc.top );
+ DWORD dwFlags = DDBLT_WAIT | ( this->bColorKeyEnable ? DDBLT_KEYSRC : 0L );
+ hr = pDest->Blt( &rcDest, this->pSurface, &rcSrc, dwFlags, NULL );
+
+/*
+ // \93]\91\97\90æ\82ª\83r\83f\83I\83\81\83\82\83\8a\82È\82ç bDestOnVideo = true
+ bool bDestOnVideo;
+ DDSCAPS2 ddsc;
+ ZeroMemory( &ddsc, sizeof( DDSCAPS2 ) );
+ pDest->GetCaps( &ddsc );
+ bDestOnVideo = ( ddsc.dwCaps & DDSCAPS_SYSTEMMEMORY ) ? false : true;
+
+ // \93]\91\97\81i\95`\89æ\81j
+ HRESULT hr;
+ if( bDestOnVideo )
+ {
+ // \93]\91\97\90æ\82ª\83r\83f\83I\83\81\83\82\83\8a\82È\82çBltFast()\82ð\8eg\82¤
+ DWORD dwFlags = DDBLTFAST_WAIT | ( this->bColorKeyEnable ? DDBLTFAST_SRCCOLORKEY : DDBLTFAST_NOCOLORKEY );
+ if( FAILED( hr = pDest->BltFast( x, y, m_pSurface, &rcSrc, dwFlags ) ) )
+ {
+ // \8e¸\94s\82µ\82½\82çBlt()\82ð\8eg\82¤
+ RECT rcDest = { x, y, x+rcSrc.right-rcSrc.left, y+rcSrc.bottom-rcSrc.top };
+ dwFlags = DDBLT_WAIT | ( this->bColorKeyEnable ? DDBLT_KEYSRC : 0L );
+ hr = pDest->Blt( &rcDest, m_pSurface, &rcSrc, dwFlags, NULL );
+ return hr;
+ }
+ }
+ else
+ {
+ // \93]\91\97\90æ\82ª\83V\83X\83e\83\80\83\81\83\82\83\8a\82È\82çBlt()\82ð\8eg\82¤
+ RECT rcDest = { x, y, x+rcSrc.right-rcSrc.left, y+rcSrc.bottom-rcSrc.top };
+ DWORD dwFlags = DDBLT_WAIT | ( this->bColorKeyEnable ? DDBLT_KEYSRC : 0L );
+ hr = pDest->Blt( &rcDest, m_pSurface, &rcSrc, dwFlags, NULL );
+ return hr;
+ }
+*/
+ return hr;
+}
+
+HRESULT CSurface::BlendDraw( LPDIRECTDRAWSURFACE7 pDest, int x, int y, LPCRECT prcSrc )
+{
+ if( ! this->pSurface || ! pDest )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+
+ RECT rcSrc = { 0, 0, this->dwWidth, this->dwHeight };
+ if( prcSrc == NULL ) prcSrc = &rcSrc;
+
+ this->LostCheck(); // \83\8d\83X\83g\82µ\82Ä\82¢\82ê\82Î\95\9c\8b\8c\82·\82é
+
+ // \93]\91\97\90æ\83T\81[\83t\83F\83C\83X\82Ì\83\8d\83b\83N
+ DDSURFACEDESC2 ddsdDst;
+ ::ZeroMemory( &ddsdDst, sizeof(ddsdDst) );
+ ddsdDst.dwSize = sizeof(ddsdDst);
+ if( FAILED( pDest->Lock( NULL, &ddsdDst, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR, NULL ) ) )
+ return FDKERR_Lock\82É\8e¸\94s;
+
+ // \93]\91\97\8c³\83T\81[\83t\83F\83C\83X\82Ì\83\8d\83b\83N
+ DDSURFACEDESC2 ddsdSrc;
+ ::ZeroMemory( &ddsdSrc, sizeof(ddsdSrc) );
+ ddsdSrc.dwSize = sizeof(ddsdSrc);
+ if( FAILED( this->pSurface->Lock( NULL, &ddsdSrc, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR, NULL ) ) )
+ return FDKERR_Lock\82É\8e¸\94s;
+
+ switch( ddsdDst.ddpfPixelFormat.dwRGBBitCount )
+ {
+ case 4: // 16\90F\94ñ\91Î\89\9e
+ case 8: // 256\90F\94ñ\91Î\89\9e
+ break;
+
+ case 16:
+ switch( ddsdSrc.ddpfPixelFormat.dwRGBBitCount )
+ {
+ case 16: BlendDraw16to16( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ case 24: BlendDraw24to16( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ case 32: BlendDraw32to16( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ }
+ break;
+
+ case 24:
+ {
+ switch( ddsdSrc.ddpfPixelFormat.dwRGBBitCount )
+ {
+ case 16: BlendDraw16to24( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ case 24: BlendDraw24to24( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ case 32: BlendDraw32to24( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ }
+ } break;
+
+ case 32:
+ switch( ddsdSrc.ddpfPixelFormat.dwRGBBitCount )
+ {
+ case 16: BlendDraw16to32( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ case 24: BlendDraw24to32( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ case 32: BlendDraw32to32( &ddsdSrc, prcSrc, &ddsdDst, x, y ); break;
+ }
+ break;
+ }
+
+ this->pSurface->Unlock( NULL );
+ pDest->Unlock( NULL );
+ return S_OK;
+}
+
+void CSurface::BlendDraw32to32( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ DWORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ DWORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = BitCount( MaskDst[i] );
+ MaskDstShift[i] = ShiftCount( MaskDst[i] );
+ }
+
+ DWORD *ps = (DWORD*)pddsdSrc->lpSurface;
+ DWORD *pd = (DWORD*)pddsdDst->lpSurface;
+
+ ps = (DWORD*)((BYTE*)ps+(lPitchSrc *prcSrc->top)) + prcSrc->left - x; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = (DWORD*)((BYTE*)pd+(lPitchDst *y)); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x; x3 < x2; x3++ )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ DWORD srcpx[3], dstpx[3], pixel=0;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx[i] = ( ps[x3] & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx[i] <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx[i] >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx[i] <<= MaskDstShift[i];
+
+ dstpx[i] = pd[x3] & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ // \90æ\82É DWORD\81~a \82·\82é\82Ì\82Å\81A\8c\85\82 \82Ó\82ê\82µ\82È\82¢\82æ\82¤ DWORDLONG \82Å\83\89\83b\83s\83\93\83O\82·\82é\81B
+ pixel |= ( ( (DWORDLONG)srcpx[i]*(a) + (DWORDLONG)dstpx[i]*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3] = pixel;
+ }
+ ps = (DWORD*)((BYTE*)ps+lPitchSrc );
+ pd = (DWORD*)((BYTE*)pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+}
+
+void CSurface::BlendDraw32to24( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ DWORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ DWORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = BitCount( MaskDst[i] );
+ MaskDstShift[i] = ShiftCount( MaskDst[i] );
+ }
+
+ DWORD *ps = (DWORD*)pddsdSrc->lpSurface;
+ BYTE *pd = ( BYTE*)pddsdDst->lpSurface;
+
+ ps = (DWORD*)((BYTE*)ps+(lPitchSrc *prcSrc->top)) + prcSrc->left - x; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = ( BYTE*)((BYTE*)pd+(lPitchDst *y)); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x; x3 < x2; x3++ )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ DWORD srcpx[3], dstpx[3], pixel;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx[i] = ( ps[x3] & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx[i] <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx[i] >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx[i] <<= MaskDstShift[i];
+
+ dstpx[i] = ( pd[x3*3] | (pd[x3*3+1]<<8) | (pd[x3*3+2]<<16) ) & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ // \90æ\82É DWORD\81~a \82·\82é\82Ì\82Å\81A\8c\85\82 \82Ó\82ê\82µ\82È\82¢\82æ\82¤ DWORDLONG \82Å\83\89\83b\83s\83\93\83O\82·\82é\81B
+ pixel |= ( ( (DWORDLONG)srcpx[i]*(a) + (DWORDLONG)dstpx[i]*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3*3+0] = (BYTE)((pixel >> 0) & 0xFF);
+ pd[x3*3+1] = (BYTE)((pixel >> 8) & 0xFF);
+ pd[x3*3+2] = (BYTE)((pixel >> 16) & 0xFF);
+ }
+ ps = (DWORD*)((BYTE*)ps+lPitchSrc );
+ pd = ( BYTE*)((BYTE*)pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+}
+
+void CSurface::BlendDraw32to16( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ DWORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ DWORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = BitCount( MaskDst[i] );
+ MaskDstShift[i] = ShiftCount( MaskDst[i] );
+ }
+
+ DWORD *ps = (DWORD*)pddsdSrc->lpSurface;
+ WORD *pd = ( WORD*)pddsdDst->lpSurface;
+
+ ps = (DWORD*)((BYTE*)ps+(lPitchSrc *prcSrc->top)) + prcSrc->left - x; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = ( WORD*)((BYTE*)pd+(lPitchDst *y)); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x; x3 < x2; x3++ )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ DWORD srcpx[3], dstpx[3], pixel=0;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx[i] = ( ps[x3] & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx[i] <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx[i] >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx[i] <<= MaskDstShift[i];
+
+ dstpx[i] = pd[x3] & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ pixel |= ( ( (DWORD)srcpx[i]*(a) + (DWORD)dstpx[i]*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3] = (WORD) pixel;
+ }
+ ps = (DWORD*)((BYTE*)ps+lPitchSrc );
+ pd = ( WORD*)((BYTE*)pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+
+}
+
+void CSurface::BlendDraw24to32( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ DWORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ DWORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = BitCount( MaskDst[i] );
+ MaskDstShift[i] = ShiftCount( MaskDst[i] );
+ }
+
+ BYTE *ps = ( BYTE*)pddsdSrc->lpSurface;
+ DWORD *pd = (DWORD*)pddsdDst->lpSurface;
+
+ ps = ( BYTE*)((BYTE*)ps+(lPitchSrc *prcSrc->top)) + prcSrc->left - x; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = (DWORD*)((BYTE*)pd+(lPitchDst *y)); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x; x3 < x2; x3++ )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ DWORD srcpx[3], dstpx[3], pixel=0;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx[i] = ( ( ps[x3*3] | (ps[x3*3+1]<<8) | (ps[x3*3+2]<<16) ) & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx[i] <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx[i] >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx[i] <<= MaskDstShift[i];
+
+ dstpx[i] = pd[x3] & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ // \90æ\82É DWORD\81~a \82·\82é\82Ì\82Å\81A\8c\85\82 \82Ó\82ê\82µ\82È\82¢\82æ\82¤ DWORDLONG \82Å\83\89\83b\83s\83\93\83O\82·\82é\81B
+ pixel |= ( ( (DWORDLONG)srcpx[i]*(a) + (DWORDLONG)dstpx[i]*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3] = pixel;
+ }
+ ps = ( BYTE*)((BYTE*)ps+lPitchSrc );
+ pd = (DWORD*)((BYTE*)pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+}
+
+void CSurface::BlendDraw24to24( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ DWORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ DWORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = BitCount( MaskDst[i] );
+ MaskDstShift[i] = ShiftCount( MaskDst[i] );
+ }
+
+ BYTE *ps = (BYTE*)pddsdSrc->lpSurface;
+ BYTE *pd = (BYTE*)pddsdDst->lpSurface;
+
+ ps = (BYTE*)ps+(lPitchSrc*prcSrc->top) + (prcSrc->left - x)*3; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = (BYTE*)pd+(lPitchDst*y); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x*3; x3 < x2*3 ; x3 += 3 )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ DWORD srcpx[3], dstpx[3], pixel=0;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx[i] = ( (ps[x3] | (ps[x3+1] << 8) | (ps[x3+2] << 16)) & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx[i] <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx[i] >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx[i] <<= MaskDstShift[i];
+
+ dstpx[i] = pd[x3] & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ // \90æ\82É DWORD\81~a \82·\82é\82Ì\82Å\81A\8c\85\82 \82Ó\82ê\82µ\82È\82¢\82æ\82¤ DWORDLONG \82Å\83\89\83b\83s\83\93\83O\82·\82é\81B\81i\8eÀ\8dÛ\82Í24bit\82¾\82©\82ç\82 \82Ó\82ê\82È\82¢\82Æ\8ev\82¤\82ª\88ê\89\9e\81B\81j
+ pixel |= ( ( (DWORDLONG)srcpx[i]*(a) + (DWORDLONG)dstpx[i]*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3+0] = (BYTE)((pixel >> 0) & 0xFF);
+ pd[x3+1] = (BYTE)((pixel >> 8) & 0xFF);
+ pd[x3+2] = (BYTE)((pixel >> 16) & 0xFF);
+ }
+ ps = (BYTE*)(ps+lPitchSrc );
+ pd = (BYTE*)(pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+}
+
+void CSurface::BlendDraw24to16( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ WORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ WORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = (WORD)pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = (WORD)pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = (WORD)pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = (WORD)pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = (WORD)pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = (WORD)pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = (WORD)pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = (WORD)pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = (WORD)BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = (WORD)ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = (WORD)BitCount( MaskDst[i] );
+ MaskDstShift[i] = (WORD)ShiftCount( MaskDst[i] );
+ }
+
+ BYTE *ps = (BYTE*)pddsdSrc->lpSurface;
+ WORD *pd = (WORD*)pddsdDst->lpSurface;
+
+ ps = (BYTE*)((BYTE*)ps+(lPitchSrc*prcSrc->top)) + prcSrc->left - x; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = (WORD*)((BYTE*)pd+(lPitchDst*y)); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x; x3 < x2; x3++ )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ WORD srcpx[3], dstpx[3], pixel=0;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx[i] = ( ( ps[x3*3] | (ps[x3*3+1]<<8) | (ps[x3*3+2]<<16) ) & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx[i] <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx[i] >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx[i] <<= MaskDstShift[i];
+
+ dstpx[i] = pd[x3] & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ // \90æ\82É WORD\81~a \82·\82é\82Ì\82Å\81A\8c\85\82 \82Ó\82ê\82µ\82È\82¢\82æ\82¤ DWORD \82Å\83\89\83b\83s\83\93\83O\82·\82é\81B
+ pixel |= ( ( (DWORD)srcpx[i]*(a) + (DWORD)dstpx[i]*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3] = pixel;
+ }
+ ps = (BYTE*)((BYTE*)ps+lPitchSrc );
+ pd = (WORD*)((BYTE*)pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+}
+
+void CSurface::BlendDraw16to32( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ DWORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ DWORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = BitCount( MaskDst[i] );
+ MaskDstShift[i] = ShiftCount( MaskDst[i] );
+ }
+
+ WORD *ps = ( WORD*)pddsdSrc->lpSurface;
+ DWORD *pd = (DWORD*)pddsdDst->lpSurface;
+
+ ps = ( WORD*)((BYTE*)ps+(lPitchSrc *prcSrc->top)) + prcSrc->left - x; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = (DWORD*)((BYTE*)pd+(lPitchDst *y)); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x; x3 < x2; x3++ )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ DWORD srcpx[3], dstpx[3], pixel = 0;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx[i] = ( ps[x3] & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx[i] <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx[i] >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx[i] <<= MaskDstShift[i];
+
+ dstpx[i] = pd[x3] & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ // \90æ\82É DWORD\81~a \82·\82é\82Ì\82Å\81A\8c\85\82 \82Ó\82ê\82µ\82È\82¢\82æ\82¤ DWORDLONG \82Å\83\89\83b\83s\83\93\83O\82·\82é\81B
+ pixel |= ( ( (DWORDLONG)srcpx[i]*(a) + (DWORDLONG)dstpx[i]*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3] = pixel;
+ }
+ ps = ( WORD*)((BYTE*)ps+lPitchSrc );
+ pd = (DWORD*)((BYTE*)pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+}
+
+void CSurface::BlendDraw16to24( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ DWORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ DWORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = BitCount( MaskDst[i] );
+ MaskDstShift[i] = ShiftCount( MaskDst[i] );
+ }
+
+ WORD *ps = (WORD*)pddsdSrc->lpSurface;
+ BYTE *pd = (BYTE*)pddsdDst->lpSurface;
+
+ ps = (WORD*)((BYTE*)ps+(lPitchSrc *prcSrc->top)) + prcSrc->left - x; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = (BYTE*)((BYTE*)pd+(lPitchDst *y)); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x; x3 < x2; x3++ )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ DWORD srcpx[3], dstpx[3], pixel=0;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx[i] = ( ps[x3] & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx[i] <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx[i] >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx[i] <<= MaskDstShift[i];
+
+ dstpx[i] = ( pd[x3*3] | (pd[x3*3+1]<<8) | (pd[x3*3+2]<<16) ) & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ // \90æ\82É DWORD\81~a \82·\82é\82Ì\82Å\81A\8c\85\82 \82Ó\82ê\82µ\82È\82¢\82æ\82¤ DWORDLONG \82Å\83\89\83b\83s\83\93\83O\82·\82é\81B
+ pixel |= ( ( (DWORDLONG)srcpx[i]*(a) + (DWORDLONG)dstpx[i]*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3*3+0] = (BYTE)((pixel >> 0) & 0xFF);
+ pd[x3*3+1] = (BYTE)((pixel >> 8) & 0xFF);
+ pd[x3*3+2] = (BYTE)((pixel >> 16) & 0xFF);
+ }
+ ps = (WORD*)((BYTE*)ps+lPitchSrc );
+ pd = (BYTE*)((BYTE*)pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+}
+
+void CSurface::BlendDraw16to16( LPDDSURFACEDESC2 pddsdSrc, LPCRECT prcSrc, LPDDSURFACEDESC2 pddsdDst, int x, int y )
+{
+ int x2 = x + prcSrc->right - prcSrc->left; /* x2 = x + Width */
+ int y2 = y + prcSrc->bottom - prcSrc->top; /* y2 = y + Height */
+
+ int a = this->nAlphaConst;
+ if( a == 255 ) a = 256;
+
+ LONG lPitchDst = pddsdDst->lPitch;
+ LONG lPitchSrc = pddsdSrc->lPitch;
+
+ // \88È\89º\81A\90F\8aÖ\8cW\82Ì\94z\97ñ\95Ï\90\94\82Ì\93Y\82¦\8e\9a\82Í [0]=R, [1]=G, [2]=B, [3]=A \82Æ\82·\82é\81B
+ WORD MaskSrc[4], MaskSrcBit[4], MaskSrcShift[4];
+ WORD MaskDst[4], MaskDstBit[4], MaskDstShift[4];
+
+ MaskSrc[0] = (WORD)pddsdSrc->ddpfPixelFormat.dwRBitMask;
+ MaskSrc[1] = (WORD)pddsdSrc->ddpfPixelFormat.dwGBitMask;
+ MaskSrc[2] = (WORD)pddsdSrc->ddpfPixelFormat.dwBBitMask;
+ MaskSrc[3] = (WORD)pddsdSrc->ddpfPixelFormat.dwRGBAlphaBitMask;
+ MaskDst[0] = (WORD)pddsdDst->ddpfPixelFormat.dwRBitMask;
+ MaskDst[1] = (WORD)pddsdDst->ddpfPixelFormat.dwGBitMask;
+ MaskDst[2] = (WORD)pddsdDst->ddpfPixelFormat.dwBBitMask;
+ MaskDst[3] = (WORD)pddsdDst->ddpfPixelFormat.dwRGBAlphaBitMask;
+ for( int i = 0; i < 4; i++ ) {
+ MaskSrcBit[i] = (WORD)BitCount( MaskSrc[i] );
+ MaskSrcShift[i] = (WORD)ShiftCount( MaskSrc[i] );
+ MaskDstBit[i] = (WORD)BitCount( MaskDst[i] );
+ MaskDstShift[i] = (WORD)ShiftCount( MaskDst[i] );
+ }
+
+ WORD *ps = (WORD*)pddsdSrc->lpSurface;
+ WORD *pd = (WORD*)pddsdDst->lpSurface;
+
+ ps = (WORD*)((BYTE*)ps+(lPitchSrc*prcSrc->top)) + prcSrc->left - x; // \93]\91\97\8c³\82Ì\8aJ\8en (x,y) \8dÀ\95W
+ pd = (WORD*)((BYTE*)pd+(lPitchDst*y)); // \93]\91\97\90æ\82Ì\8aJ\8en (0,y) \8dÀ\95W
+
+ for( int y3 = y; y3 < y2; y3++ )
+ {
+ for( int x3 = x; x3 < x2; x3++ )
+ {
+ // srcpx[] \81¨ \93]\91\97\8c³\82Ì\90F\82ð\93]\91\97\90æ\82ÌRGBA\83t\83H\81[\83}\83b\83g\82É\91\9d\8c¸\90F
+ // dstpx[] \81¨ \93]\91\97\90æ\82Ì\90F
+ WORD srcpx, dstpx, pixel = 0;
+ for( int i = 0; i < 3; i++ )
+ {
+ srcpx = ( ps[x3] & MaskSrc[i] ) >> MaskSrcShift[i];
+
+ if( MaskSrcBit[i] < MaskDstBit[i] ) // \97á: Bit\90\94 4 \81¨ 5 \82È\82ç
+ srcpx <<= ( MaskDstBit[i] - MaskSrcBit[i] ); // 1 \82¾\82¯\8d¶\82É\83V\83t\83g\82·\82é\81B
+ else if( MaskSrcBit[i] > MaskDstBit[i] ) // \97á: BitCount 5 \81¨ 4 \82È\82ç
+ srcpx >>= ( MaskSrcBit[i] - MaskDstBit[i] ); // 1 \82¾\82¯\89E\82É\83V\83t\83g\82·\82é\81B
+ srcpx <<= MaskDstShift[i];
+
+ dstpx = pd[x3] & MaskDst[i];
+
+ // \90V\93]\91\97\90æ = \93]\91\97\8c³\81~\83¿ + \93]\91\97\90æ\81~(1-\83¿);
+ // \90æ\82É WORD\81~a \82·\82é\82Ì\82Å\81A\8c\85\82 \82Ó\82ê\82µ\82È\82¢\82æ\82¤ DWORD \82Å\83\89\83b\83s\83\93\83O\82·\82é\81B
+ pixel |= ( ( (DWORD)srcpx*(a) + (DWORD)dstpx*(256-a) ) >> 8 ) & MaskDst[i];
+ }
+ if( MaskDst[3] != 0 ) pixel |= MaskDst[3]; // \93]\91\97\90æ\82É\83A\83\8b\83t\83@\83r\83b\83g\82ª\82 \82é\82È\82ç\8fí\82ÉMAX\82ð\90Ý\92è
+ pd[x3] = pixel;
+ }
+ ps = (WORD*)((BYTE*)ps+lPitchSrc );
+ pd = (WORD*)((BYTE*)pd+lPitchDst ); // \82P\83\89\83X\83^\95ª\82Ì\91\9d\97Ê
+ // BYTE\82É\83L\83\83\83X\83g\82µ\82Ä\82¨\82©\82È\82¢\82Æ\8cv\8eZ\8aÔ\88á\82¤
+ }
+}
+
+DWORD CSurface::BitCount( DWORD dwNum )
+{
+ DWORD dwCount;
+ for( dwCount = 0; dwNum != 0; dwNum >>= 1 )
+ dwCount += ( dwNum & 0x1 );
+ return dwCount;
+}
+
+DWORD CSurface::ShiftCount( DWORD dwNum )
+{
+ if( dwNum == 0 ) return 0; // \83[\83\8d\82Ì\82Æ\82«\82Í\83[\83\8d\82ð\95Ô\82·\81B
+
+ DWORD dwCount;
+ for( dwCount = 0; (dwNum & 0x1) == 0; dwNum >>= 1 )
+ dwCount ++;
+
+ return dwCount;
+}
+
+HRESULT CSurface::Text( int x, int y, HFONT hFont, LPCTSTR str, COLORREF color )
+{
+ if( ! this->pSurface )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+
+ if( !str || *str == _T('\0') )
+ return S_OK;
+
+ this->LostCheck(); // \83\8d\83X\83g\82µ\82Ä\82¢\82ê\82Î\95\9c\8b\8c\82·\82é
+
+ HRESULT hr;
+
+ HDC hDC;
+ if( FAILED( hr = this->pSurface->GetDC( &hDC ) ) )
+ return FDKERR_DC\82Ì\8eæ\93¾\82É\8e¸\94s;
+
+ HFONT hOldFont = (HFONT) ::SelectObject( hDC, hFont );
+
+ ::SetBkMode( hDC, TRANSPARENT );
+ ::SetTextColor( hDC, color );
+ ::TextOut( hDC, x, y, str, lstrlen( str ) );
+
+ ::SelectObject( hDC, hOldFont );
+ this->pSurface->ReleaseDC( hDC );
+
+ return S_OK;
+}
+
+HRESULT CSurface::TextSharp( int x, int y, HFONT hFont, LPCTSTR str, COLORREF color )
+{
+ if( ! this->pSurface )
+ return FDKERR_\83T\81[\83t\83F\83C\83X\82ªNULL;
+
+ if( !str || *str == _T('\0') )
+ return S_OK;
+
+ this->LostCheck(); // \83\8d\83X\83g\82µ\82Ä\82¢\82ê\82Î\95\9c\8b\8c\82·\82é
+
+ // \96Ê\90Ï\82S\94{\82Ì BITMAP \82ð\8dì\90¬
+ BITMAPINFOHEADER bmi;
+ ZeroMemory( &bmi, sizeof( BITMAPINFOHEADER ) );
+ bmi.biSize = sizeof( BITMAPINFOHEADER );
+ bmi.biWidth = ( (LONG)(this->dwWidth - x) ) * 2;
+ bmi.biHeight = ( - ((LONG)(this->dwHeight - y)) ) * 2;
+ bmi.biPlanes = 1;
+ bmi.biBitCount = 32;
+ HDC hDC = CreateCompatibleDC( 0 );
+ HBITMAP hBmp = CreateDIBSection( hDC, (BITMAPINFO *)&bmi, DIB_RGB_COLORS, NULL, NULL, 0 );
+
+ // \83\81\83\82\83\8aDC \82ð\8eg\82Á\82Ä BITMAP \82Ö\83e\83L\83X\83g\95`\89æ
+ HBITMAP hOldBmp = (HBITMAP) SelectObject( hDC, hBmp );
+ HFONT hOldFont = (HFONT) SelectObject( hDC, hFont );
+ SetTextColor( hDC, color );
+ SetBkColor( hDC, RGB(0,0,0) );
+ RECT rc = { 0, 0, (this->dwWidth-x)*2, (this->dwHeight-y)*2 };
+ DrawText( hDC, str, lstrlen(str), &rc, DT_LEFT|DT_NOPREFIX );
+ SelectObject( hDC, hOldFont );
+ SelectObject( hDC, hOldBmp );
+ DeleteDC( hDC );
+
+ // \83r\83b\83g\83}\83b\83v\82©\82ç\83T\81[\83t\83F\83C\83X\82Ö\93]\91\97
+ BITMAP bmp;
+ GetObject( hBmp, sizeof(BITMAP), &bmp );
+ CopyFromBMP32x4( x, y, &bmp, true );
+ DeleteObject( hBmp );
+
+ return S_OK;
+}
+int CSurface::GetTextWidthDot( HFONT hFont, LPCTSTR str\95¶\8e\9a\97ñ )
+{
+ HDC hdc = ::CreateCompatibleDC( 0 );
+ HFONT hOldFont = (HFONT) ::SelectObject( hdc, hFont );
+ SIZE size;
+ ::GetTextExtentPoint32( hdc, str\95¶\8e\9a\97ñ, lstrlen(str\95¶\8e\9a\97ñ), &size );
+ ::SelectObject( hdc, hOldFont );
+ ::DeleteDC( hdc );
+ return (int) size.cx;
+}
+void CSurface::CopyFromBMP32x4( int x, int y, BITMAP* bmp, bool bSkipBlack )
+{
+ DDSURFACEDESC2 ddsd;
+ ZeroMemory( &ddsd, sizeof( DDSURFACEDESC2 ) );
+ ddsd.dwSize = sizeof( DDSURFACEDESC2 );
+
+ if( SUCCEEDED( this->pSurface->Lock( NULL, &ddsd, DDLOCK_WAIT|DDLOCK_WRITEONLY, NULL ) ) )
+ {
+ BYTE* src_line = (BYTE*) bmp->bmBits;
+ BYTE* dst_line = (BYTE*) ddsd.lpSurface;
+
+ // A. \93]\91\97\90æ\83T\81[\83t\83F\83C\83X\82ª 32bpp \82Ì\8fê\8d\87
+ if( ddsd.ddpfPixelFormat.dwRGBBitCount == 32 )
+ {
+ for( int ly = 0; ly < (LONG)this->dwHeight; ly++ )
+ {
+ if( ly >= y )
+ {
+ DWORD* src = (DWORD*) src_line;
+ DWORD* dst = (DWORD*) dst_line;
+ for( int lx = 0; lx < (LONG)this->dwWidth; lx++ )
+ {
+ if( lx >= x )
+ {
+ DWORD s, s1[4], s2[4], s3[4];
+ s = *src;
+ s1[0] = s & 0x00FF0000;
+ s2[0] = s & 0x0000FF00;
+ s3[0] = s & 0x000000FF;
+ s = *(src + 1);
+ s1[1] = s & 0x00FF0000;
+ s2[1] = s & 0x0000FF00;
+ s3[1] = s & 0x000000FF;
+ s = *((DWORD*)(((BYTE*)src) + bmp->bmWidthBytes));
+ s1[2] = s & 0x00FF0000;
+ s2[2] = s & 0x0000FF00;
+ s3[2] = s & 0x000000FF;
+ s = *((DWORD*)(((BYTE*)src) + bmp->bmWidthBytes) + 1);
+ s1[3] = s & 0x00FF0000;
+ s2[3] = s & 0x0000FF00;
+ s3[3] = s & 0x000000FF;
+
+ DWORD A = 255; // \83A\83\8b\83t\83@\82Í\8fí\82É255
+
+ bool bAllBlack = false; // bSkipBlack \8e\9e\82É\83X\83L\83b\83v\82·\82é\82©\94Û\82©\82Í\81A\82S\82Â\82Ì\90F\82ª\81u\82·\82×\82Ä\8d\95\81v\82©\81u\82Ð\82Æ\82Â\82Å\82à\8d\95\82Å\82È\82¢\81v\82©\82¾\82¯\82Å\8c\88\82ß\82é\81B
+ for( int i = 0; i < 4; i++ ) {
+ if( ! ( s1[i] == 0 && s2[i] == 0 && s3[i] == 0 ) ) {
+ bAllBlack = true;
+ break;
+ }
+ }
+
+ if( ! ( bSkipBlack && bAllBlack == 0 ) ) // \82S\82Â\82Ì\90F\82ª\82·\82×\82Ä\8d\95 \82©\82Â bSkipBlack=true \82È\82ç\93]\91\97\82µ\82È\82¢\81B
+ {
+ DWORD c1 = ((( s1[0] + s1[1] + s1[2] + s1[3] ) >> 2) & ddsd.ddpfPixelFormat.dwRBitMask );
+ DWORD c2 = ((( s2[0] + s2[1] + s2[2] + s2[3] ) >> 2) & ddsd.ddpfPixelFormat.dwGBitMask );
+ DWORD c3 = ((( s3[0] + s3[1] + s3[2] + s3[3] ) >> 2) & ddsd.ddpfPixelFormat.dwBBitMask );
+ DWORD c4 = (A << 24);
+ *dst = c1 | c2 | c3 | c4;
+ }
+ src += 2;
+ }
+ dst ++;
+ }
+ src_line += bmp->bmWidthBytes * 2;
+ }
+ dst_line += ddsd.lPitch;
+ }
+ }
+ // B. \93]\91\97\90æ\83T\81[\83t\83F\83C\83X\82ª 16/24bpp \82Ì\8fê\8d\87
+ else if ( ddsd.ddpfPixelFormat.dwRGBBitCount == 16 || ddsd.ddpfPixelFormat.dwRGBBitCount == 24 )
+ {
+ // \93]\91\97\90æ\83}\83X\83N\82Ì\82»\82ê\82¼\82ê\82Ì\83r\83b\83g\90\94\82Æ\83V\83t\83g\90\94\82ð\8b\81\82ß\82é
+ int nBit\90\94R = this->BitCount( ddsd.ddpfPixelFormat.dwRBitMask );
+ int nBit\90\94G = this->BitCount( ddsd.ddpfPixelFormat.dwGBitMask );
+ int nBit\90\94B = this->BitCount( ddsd.ddpfPixelFormat.dwBBitMask );
+ int nBit\90\94A = this->BitCount( ddsd.ddpfPixelFormat.dwRGBAlphaBitMask );
+ int nShift\90\94R = this->ShiftCount( ddsd.ddpfPixelFormat.dwRBitMask );
+ int nShift\90\94G = this->ShiftCount( ddsd.ddpfPixelFormat.dwGBitMask );
+ int nShift\90\94B = this->ShiftCount( ddsd.ddpfPixelFormat.dwBBitMask );
+ int nShift\90\94A = this->ShiftCount( ddsd.ddpfPixelFormat.dwRGBAlphaBitMask );
+
+ for( int ly = 0; ly < (LONG)this->dwHeight; ly++ )
+ {
+ if( ly >= y )
+ {
+ DWORD* src = (DWORD*) src_line;
+ WORD* dst = (WORD*) dst_line;
+ for( int lx = 0; lx < (LONG)this->dwWidth; lx++ )
+ {
+ if( lx >= x )
+ {
+ DWORD s;
+ DWORD s1[4], s2[4], s3[4];
+ s = *src;
+ s1[0] = (s & 0x00FF0000) >> (16 + (8 - nBit\90\94R));
+ s2[0] = (s & 0x0000FF00) >> ( 8 + (8 - nBit\90\94G));
+ s3[0] = (s & 0x000000FF) >> ( 0 + (8 - nBit\90\94B));
+ s = *(src + 1);
+ s1[1] = (s & 0x00FF0000) >> (16 + (8 - nBit\90\94R));
+ s2[1] = (s & 0x0000FF00) >> ( 8 + (8 - nBit\90\94G));
+ s3[1] = (s & 0x000000FF) >> ( 0 + (8 - nBit\90\94B));
+ s = *((DWORD*)(((BYTE*)src) + bmp->bmWidthBytes));
+ s1[2] = (s & 0x00FF0000) >> (16 + (8 - nBit\90\94R));
+ s2[2] = (s & 0x0000FF00) >> ( 8 + (8 - nBit\90\94G));
+ s3[2] = (s & 0x000000FF) >> ( 0 + (8 - nBit\90\94B));
+ s = *((DWORD*)(((BYTE*)src) + bmp->bmWidthBytes) + 1);
+ s1[3] = (s & 0x00FF0000) >> (16 + (8 - nBit\90\94R));
+ s2[3] = (s & 0x0000FF00) >> ( 8 + (8 - nBit\90\94G));
+ s3[3] = (s & 0x000000FF) >> ( 0 + (8 - nBit\90\94B));
+
+ WORD A = (WORD) ddsd.ddpfPixelFormat.dwRGBAlphaBitMask; // \83A\83\8b\83t\83@\82Í\8fí\82É\8dÅ\91å
+
+ bool bAllBlack = false; // bSkipBlack \8e\9e\82É\83X\83L\83b\83v\82·\82é\82©\94Û\82©\82Í\81A\82S\82Â\82Ì\90F\82ª\81u\82·\82×\82Ä\8d\95\81v\82©\81u\82Ð\82Æ\82Â\82Å\82à\8d\95\82Å\82È\82¢\81v\82©\82¾\82¯\82Å\8c\88\82ß\82é\81B
+ for( int i = 0; i < 4; i++ ) {
+ if( ! ( s1[i] == 0 && s2[i] == 0 && s3[i] == 0 ) ) {
+ bAllBlack = true;
+ break;
+ }
+ }
+
+ if( ! ( bSkipBlack && bAllBlack == 0 ) ) // \82S\82Â\82Ì\90F\82ª\82·\82×\82Ä\8d\95 \82©\82Â bSkipBlack=true \82È\82ç\93]\91\97\82µ\82È\82¢\81B
+ {
+ WORD c1 = (WORD)(((( s1[0] + s1[1] + s1[2] + s1[3] ) >> 2) << nShift\90\94R ) & ddsd.ddpfPixelFormat.dwRBitMask );
+ WORD c2 = (WORD)(((( s2[0] + s2[1] + s2[2] + s2[3] ) >> 2) << nShift\90\94G ) & ddsd.ddpfPixelFormat.dwGBitMask );
+ WORD c3 = (WORD)(((( s3[0] + s3[1] + s3[2] + s3[3] ) >> 2) << nShift\90\94B ) & ddsd.ddpfPixelFormat.dwBBitMask );
+ *dst = c1 | c2 | c3 | A;
+ }
+ src += 2;
+ }
+ dst ++;
+ }
+ src_line += bmp->bmWidthBytes * 2;
+ }
+ dst_line += ddsd.lPitch;
+ }
+ }
+
+ this->pSurface->Unlock( NULL );
+ }
+}
+void CSurface::LostCheck()
+{
+ if( this->pSurface != NULL
+ && this->pSurface->IsLost() == DDERR_SURFACELOST
+ && ( this->place == LOADTO_VIDEO || this->place == LOADTO_VIDEO_OR_SYSTEM ) )
+ this->RestoreDeviceObjects();
+}
+ }//Graphics
+}//FDK
\ No newline at end of file
OSDN Git Service
