Code:
#ifdef _USRDLL
#define capi static
#else
#define capi
#endif
#ifndef SAFE_RELEASE
#define SAFE_RELEASE(p) { if(p) { p->Release(); p = NULL; } }
#endif
#ifndef HEAP_FREE
#define HEAP_FREE(p) { if(p){ HeapFree(GetProcessHeap(), 0, p); p = NULL; } }
#endif
static char* aEmptyChar = "";
Code:
#define THISS IMAGE_FOR_GXD *This
#define THISC IMAGE_FOR_GXD *This,
class IMAGE_FOR_GXD
{
public:
BOOL mCheckValidState;
D3DXIMAGE_INFO mTextureInfo;
D3DFORMAT mLoadFormat;
IDirect3DTexture9* mTexture;
IMAGE_FOR_GXD( void );
~IMAGE_FOR_GXD( void );
capi void Init( THISS );
capi void Free( THISS );
capi int GetTwoPowerNumber( int tNumber );
capi BOOL Load( THISC char *tFileName );
capi void Draw( THISC int tX, int tY, BOOL tCheckExistPartInfo, int iX, int iY, int lX, int lY );
capi void Draw( THISC int tX, int tY, float tScaleX, float tScaleY );
};
#undef THISS
#undef THISC
Code:
#ifdef _USRDLL
#define THISC IMAGE_FOR_GXD* This,
#define THISS IMAGE_FOR_GXD* This
#else
#define THISC
#define THISS
#endif
IMAGE_FOR_GXD::IMAGE_FOR_GXD( void )
{
IMAGE_FOR_GXD::Init( this );
}
IMAGE_FOR_GXD::~IMAGE_FOR_GXD()
{
IMAGE_FOR_GXD::Free( this );
}
void IMAGE_FOR_GXD::Init( THISS )
{
This->mCheckValidState = FALSE;
This->mTexture = NULL;
}
void IMAGE_FOR_GXD::Free( THISS )
{
This->mCheckValidState = FALSE;
SAFE_RELEASE( This->mTexture );
}
int IMAGE_FOR_GXD::GetTwoPowerNumber( int tNumber )
{
int result;
if ( tNumber < 1 )
return 0;
for ( result = 1; result < tNumber; result *= 2 )
;
return result;
}
BOOL IMAGE_FOR_GXD::Load( THISC char *tFileName )
{
BOOL result = FALSE;
BYTE *tOriginal = NULL, *tCompress = NULL;
DWORD tOriginalSize, tCompressSize;
DWORD tReadBytes;
HANDLE hFile = CreateFileA(tFileName, 0x80000000, 1u, 0, 3u, 0x80u, 0 );
if( hFile == INVALID_HANDLE_VALUE )
{
IMAGE_FOR_GXD::Free(This);
return FALSE;
}
DWORD size = GetFileSize( hFile, 0 );
if( size == INVALID_FILE_SIZE )
goto RET;
tCompress = (BYTE*)HeapAlloc( GetProcessHeap(), 0, size );
if ( !tCompress )
{
RET:
HEAP_FREE(tOriginal);
HEAP_FREE(tCompress);
if (!result)
{
CloseHandle(hFile);
IMAGE_FOR_GXD::Free(This);
}
else
{
result = CloseHandle(hFile);
This->mCheckValidState = result;
}
return result;
}
if ( !ReadFile(hFile, tCompress, size, &tReadBytes, 0) || tReadBytes != size )
goto RET;
//typedef struct
//{
// DWORD tOriginalSize;
// DWORD tCompressSize;
// BYTE* tCompress;
//} IMAGE_FOR_COMPRESS;
tOriginalSize = *(DWORD*)&tCompress[0];
tCompressSize = *(DWORD*)&tCompress[4];
tOriginal = (BYTE*)HeapAlloc( GetProcessHeap(), 0, tOriginalSize );
if (!tOriginal)
goto RET;
if( !GXD::Decompress( tCompressSize, &tCompress[8], tOriginalSize, tOriginal ) )
goto RET;
//typedef struct
//{
// D3DXIMAGE_INFO mTextureInfo; //offset 0, size = 28
// D3DFORMAT mLoadFormat; //offset 28, size = 4
// int mTextureSize; //offset 32, size = 4
// IDirect3DTexture9 *mTexture; //offset 36, size = mTextureSize
//} IMAGE_FOR_UNCOMPRESS;
memcpy( &This->mTextureInfo, &tOriginal[0], sizeof(This->mTextureInfo) );
This->mLoadFormat = *(D3DFORMAT*)&tOriginal[28];
int textureSize = *(int*)&tOriginal[32];
int width = IMAGE_FOR_GXD::GetTwoPowerNumber( This->mTextureInfo.Width );
int height = IMAGE_FOR_GXD::GetTwoPowerNumber( This->mTextureInfo.Height );
if ( SUCCEEDED( D3DXCreateTextureFromFileInMemoryEx(
mGXD[0].mGraphicDevice,
&tOriginal[36],
textureSize,
width,
height,
1,
0,
This->mLoadFormat,
D3DPOOL_MANAGED,
1,
1,
0,
0,
0,
&This->mTexture ) )
)
{
result = TRUE;
}
goto RET;
}
void IMAGE_FOR_GXD::Draw( THISC int tX, int tY, BOOL tCheckExistPartInfo, int iX, int iY, int lX, int lY )
{
D3DXVECTOR3 pos;
RECT r;
if ( !This->mCheckValidState )
return;
if ( tCheckExistPartInfo )
{
r.left = iX;
r.top = iY;
r.right = lX + iX;
r.bottom = lY + iY;
}
else
{
r.left = 0;
r.top = 0;
r.right = This->mTextureInfo.Width;
r.bottom = This->mTextureInfo.Height;
}
pos = D3DXVECTOR3( (FLOAT)tX, (FLOAT)tY, 0.0f );
mGXD[0].mGraphicSprite->Draw( This->mTexture, &r, 0, &pos, -1 );
}
void IMAGE_FOR_GXD::Draw( THISC int tX, int tY, float tScaleX, float tScaleY )
{
D3DXVECTOR3 pos;
RECT r;
D3DXMATRIX oldTransform;
D3DXMATRIX pOut;
if ( !This->mCheckValidState )
return;
r.left = 0;
r.top = 0;
r.right = This->mTextureInfo.Width;
r.bottom = This->mTextureInfo.Height;
mGXD[0].mGraphicSprite->GetTransform( &oldTransform );
D3DXMatrixScaling( &pOut, tScaleX, tScaleY, 1.0f );
mGXD[0].mGraphicSprite->SetTransform(&pOut);
pos = D3DXVECTOR3( (FLOAT)tX, (FLOAT)tY, 0.0f );
mGXD[0].mGraphicSprite->Draw( This->mTexture, &r, 0, &pos, -1 );
mGXD[0].mGraphicSprite->SetTransform( &oldTransform );
}
#undef THISC
#undef THISS
Code:
#define THISS GIMAGE2D *This
#define THISC GIMAGE2D *This,
class GIMAGE2D
{
public:
BOOL mCheckValidState;
char mFileName[100];
IMAGE_FOR_GXD mDATA;
float mLastUsedTime;
GIMAGE2D( void );
~GIMAGE2D( void );
capi void Init( THISC int tValue1, int tValue2, int tValue3 );
capi void Free( THISS );
capi BOOL Load( THISS );
capi void ProcessForMemory( THISC float tPresentTime, float tValidTimeLength );
capi void Display( THISC int sX, int sY );
capi void Display2( THISC int sX, int sY, float tScaleX, float tScaleY );
capi BOOL CheckIn( THISC int sX, int sY, int mX, int mY );
capi WORD GetXSize( THISS );
capi WORD GetYSize( THISS );
};
#undef THISC
#undef THISS
Code:
#ifdef _USRDLL
#define THISS GIMAGE2D *This
#define THISC GIMAGE2D *This,
#else
#define THISS
#define THISC
#define This this
#endif
GIMAGE2D::GIMAGE2D( void )
{
mCheckValidState = FALSE;
IMAGE_FOR_GXD::Init( &mDATA );
}
GIMAGE2D::~GIMAGE2D( void )
{
}
void GIMAGE2D::Init( THISC int tValue01, int tValue02, int tValue03 )
{
switch ( tValue01 )
{
case 1:
sprintf( This->mFileName, "G03_GDATA\\D01_GIMAGE2D\\001\\001_%05d.IMG", tValue02 + 1 );
break;
case 2:
sprintf( This->mFileName, "G03_GDATA\\D01_GIMAGE2D\\002\\002_%05d.IMG", tValue02 + 1 );
break;
case 3:
sprintf( This->mFileName, "G03_GDATA\\D01_GIMAGE2D\\003\\003_%05d.IMG", tValue02 + 1 );
break;
case 4:
sprintf( This->mFileName, "G03_GDATA\\D01_GIMAGE2D\\004\\004_%05d.IMG", tValue02 + 1 );
break;
case 5:
sprintf( This->mFileName, "G03_GDATA\\D01_GIMAGE2D\\006\\006_%05d.IMG", tValue02 + 1 );
break;
case 6:
sprintf( This->mFileName, "G03_GDATA\\D01_GIMAGE2D\\007\\007_%03d%03d.IMG", tValue02 + 1, tValue03 + 1 );
break;
case 7:
sprintf( This->mFileName, "G03_GDATA\\D01_GIMAGE2D\\008\\008_%05d.IMG", tValue02 + 1 );
break;
default:
strcpy( This->mFileName, aEmptyChar );
return;
}
}
void GIMAGE2D::Free( THISS )
{
This->mCheckValidState = FALSE;
IMAGE_FOR_GXD::Free( &This->mDATA );
}
BOOL GIMAGE2D::Load( THISS )
{
if ( This->mCheckValidState )
return 1;
if ( !IMAGE_FOR_GXD::Load( &This->mDATA, This->mFileName ) )
return 0;
This->mCheckValidState = 1;
return 1;
}
void GIMAGE2D::ProcessForMemory( THISC float tPresentTime, float tValidTimeLength )
{
if( !This->mCheckValidState )
return;
if( ( tPresentTime - This->mLastUsedTime ) > tValidTimeLength )
{
GIMAGE2D::Free( This );
}
}
#define SETLOAD( ... ) { \
if( !This->mCheckValidState ) \
{ \
if( !GIMAGE2D::Load( This ) ) \
{ \
return __VA_ARGS__; \
} \
This->mCheckValidState = TRUE; \
} \
This->mLastUsedTime = mApp[0].hPresentElapsedSeconds; \
}
void GIMAGE2D::Display( THISC int sX, int sY )
{
SETLOAD();
IMAGE_FOR_GXD::Draw( &This->mDATA, sX, sY, FALSE, 0, 0, 0, 0 );
}
void GIMAGE2D::Display( THISC int sX, int sY, float tScaleX, float tScaleY )
{
SETLOAD();
IMAGE_FOR_GXD::Draw( &This->mDATA, sX, sY, tScaleX, tScaleY );
}
BOOL GIMAGE2D::CheckIn( THISC int sX, int sY, int mX, int mY )
{
SETLOAD(FALSE);
if( ( mX >= sX ) && ( mX < ( sX + (int) This->mDATA.mTextureInfo.Width ) ) && ( mY >= sY ) && ( mY < ( sY + (int) This->mDATA.mTextureInfo.Height ) ) )
{
return TRUE;
}
return FALSE;
}
WORD GIMAGE2D::GetXSize( THISS )
{
SETLOAD(0);
return This->mDATA.mTextureInfo.Width;
}
WORD GIMAGE2D::GetYSize( THISS )
{
SETLOAD(0);
return This->mDATA.mTextureInfo.Height;
}
Code:
GIMAGE2D img; sprintf( img.mFileName, "my.IMG" ); GIMAGE2D::Display( &img, 0, 0 ); or GIMAGE2D::Display( &img, 0, 0, 1.0f, 1.0f )
i need login send strct
