grpapi/grpapi.cpp

   1 #include "grpapi.h"\r
   2 #include "../LoadStorm/storm.h"\r
   3 #include <malloc.h>\r
   4 \r
   5 #ifdef GRPAPI_STATIC\r
   6 #define DllMain GrpMain\r
   7 \r
   8 #include "grp_static.h"\r
   9 \r
  10 struct GRPLIBMODULE {\r
  11         GRPLIBMODULE();\r
  12         ~GRPLIBMODULE();\r
  13 } GrpLib;\r
  14 \r
  15 BOOL APIENTRY DllMain(HINSTANCE hInstDLL, DWORD  ul_reason_for_call, LPVOID lpReserved);\r
  16 \r
  17 GRPLIBMODULE::GRPLIBMODULE()\r
  18 {\r
  19         GrpMain(0,DLL_PROCESS_ATTACH,0);\r
  20 }\r
  21 \r
  22 GRPLIBMODULE::~GRPLIBMODULE()\r
  23 {\r
  24         GrpMain(0,DLL_PROCESS_DETACH,0);\r
  25 }\r
  26 \r
  27 #endif\r
  28 \r
  29 typedef struct {\r
  30         BYTE Left;\r
  31         BYTE Top;\r
  32         BYTE Width;\r
  33         BYTE Height;\r
  34         DWORD Offset;\r
  35 } FRAMEHEADER;\r
  36 \r
  37 GETPIXELPROC MyGetPixel = GetPixel;\r
  38 SETPIXELPROC MySetPixel = (SETPIXELPROC)SetPixelV;\r
  39 \r
  40 void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD dwFlags, DWORD dwAlpha);\r
  41 \r
  42 extern HINSTANCE hStorm;\r
  43 \r
  44 BOOL APIENTRY DllMain( HINSTANCE hInstDLL, \r
  45                        DWORD  ul_reason_for_call, \r
  46                        LPVOID lpReserved\r
  47                                          )\r
  48 {\r
  49     switch (ul_reason_for_call)\r
  50         {\r
  51                 case DLL_PROCESS_ATTACH:\r
  52                         break;\r
  53                 case DLL_THREAD_ATTACH:\r
  54                         break;\r
  55                 case DLL_THREAD_DETACH:\r
  56                         break;\r
  57                 case DLL_PROCESS_DETACH:\r
  58                         break;\r
  59     }\r
  60 \r
  61     return TRUE;\r
  62 }\r
  63 \r
  64 BOOL GRPAPI WINAPI LoadGrpApi()\r
  65 {\r
  66         if (!hStorm) return FALSE;\r
  67         else return TRUE;\r
  68 }\r
  69 \r
  70 void GRPAPI WINAPI FreeGrpApi()\r
  71 {\r
  72 }\r
  73 \r
  74 BOOL GRPAPI WINAPI SetMpqDll(LPCSTR lpDllFileName)\r
  75 {\r
  76         if (LoadStorm((char *)lpDllFileName)) return TRUE;\r
  77         else return FALSE;\r
  78 }\r
  79 \r
  80 BOOL GRPAPI WINAPI LoadPalette(LPCSTR lpFileName, DWORD *dwPaletteBuffer)\r
  81 {\r
  82         if (!lpFileName || !dwPaletteBuffer) return FALSE;\r
  83         HANDLE hFile;\r
  84         if (SFileOpenFileEx && SFileGetFileSize\r
  85          && SFileSetFilePointer && SFileReadFile\r
  86          && SFileCloseFile) {\r
  87                 if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return FALSE;\r
  88                 DWORD fsz = SFileGetFileSize(hFile,0);\r
  89                 SFileSetFilePointer(hFile,0,0,FILE_BEGIN);\r
  90                 if (fsz>=1024) {\r
  91                         memset(dwPaletteBuffer,0,1024);\r
  92                         SFileReadFile(hFile,dwPaletteBuffer,1024,0,0);\r
  93                 }\r
  94                 else if (fsz==768) {\r
  95                         char *buffer = (char *)_alloca(768);\r
  96                         memset(buffer,0,768);\r
  97                         SFileReadFile(hFile,buffer,768,0,0);\r
  98                         for (DWORD i=0;i<256;i++) {\r
  99                                 memcpy(&dwPaletteBuffer[i],buffer+i*3,3);\r
 100                                 *(((char *)&dwPaletteBuffer[i])+3) = 0;\r
 101                         }\r
 102                 }\r
 103                 else {\r
 104                         memset(dwPaletteBuffer,0,1024);\r
 105                         SFileReadFile(hFile,dwPaletteBuffer,fsz,0,0);\r
 106                 }\r
 107                 SFileCloseFile(hFile);\r
 108         }\r
 109         else {\r
 110                 hFile = CreateFile(lpFileName,GENERIC_READ,FILE_SHARE_READ,0,OPEN_EXISTING,0,0);\r
 111                 if (hFile==INVALID_HANDLE_VALUE) return FALSE;\r
 112                 DWORD fsz = GetFileSize(hFile,0),tsz;\r
 113                 SetFilePointer(hFile,0,0,FILE_BEGIN);\r
 114                 if (fsz>=1024) {\r
 115                         memset(dwPaletteBuffer,0,1024);\r
 116                         ReadFile(hFile,dwPaletteBuffer,1024,&tsz,0);\r
 117                 }\r
 118                 else if (fsz==768) {\r
 119                         char *buffer = (char *)_alloca(768);\r
 120                         memset(buffer,0,768);\r
 121                         ReadFile(hFile,buffer,768,&tsz,0);\r
 122                         for (DWORD i=0;i<256;i++) {\r
 123                                 memcpy(&dwPaletteBuffer[i],buffer+i*3,3);\r
 124                                 *(((char *)&dwPaletteBuffer[i])+3) = 0;\r
 125                         }\r
 126                 }\r
 127                 else {\r
 128                         memset(dwPaletteBuffer,0,1024);\r
 129                         ReadFile(hFile,dwPaletteBuffer,fsz,&tsz,0);\r
 130                 }\r
 131                 CloseHandle(hFile);\r
 132         }\r
 133         return TRUE;\r
 134 }\r
 135 \r
 136 HANDLE GRPAPI WINAPI LoadGrp(LPCSTR lpFileName)\r
 137 {\r
 138         if (!lpFileName) return (HANDLE)-1;\r
 139         HANDLE hFile;\r
 140         char *GrpFile;\r
 141         if (SFileOpenFileEx && SFileGetFileSize\r
 142          && SFileSetFilePointer && SFileReadFile\r
 143          && SFileCloseFile) {\r
 144                 if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return (HANDLE)-1;\r
 145                 DWORD fsz = SFileGetFileSize(hFile,0);\r
 146                 if (fsz<6) {\r
 147                         SFileCloseFile(hFile);\r
 148                         return (HANDLE)-1;\r
 149                 }\r
 150                 GrpFile = (char *)VirtualAlloc(0,fsz,MEM_COMMIT,PAGE_READWRITE);\r
 151                 if (GrpFile) {\r
 152                         SFileSetFilePointer(hFile,0,0,FILE_BEGIN);\r
 153                         SFileReadFile(hFile,GrpFile,fsz,0,0);\r
 154                 }\r
 155                 else GrpFile=(char *)-1;\r
 156                 SFileCloseFile(hFile);\r
 157         }\r
 158         else {\r
 159                 hFile = CreateFile(lpFileName,GENERIC_READ,FILE_SHARE_READ,0,OPEN_EXISTING,0,0);\r
 160                 if (hFile==INVALID_HANDLE_VALUE) return (HANDLE)-1;\r
 161                 DWORD fsz = GetFileSize(hFile,0),tsz;\r
 162                 if (fsz<6) {\r
 163                         CloseHandle(hFile);\r
 164                         return (HANDLE)-1;\r
 165                 }\r
 166                 GrpFile = (char *)VirtualAlloc(0,fsz,MEM_COMMIT,PAGE_READWRITE);\r
 167                 if (GrpFile) {\r
 168                         SetFilePointer(hFile,0,0,FILE_BEGIN);\r
 169                         ReadFile(hFile,GrpFile,fsz,&tsz,0);\r
 170                 }\r
 171                 else GrpFile=(char *)-1;\r
 172                 CloseHandle(hFile);\r
 173         }\r
 174         return (HANDLE)GrpFile;\r
 175 }\r
 176 \r
 177 BOOL GRPAPI WINAPI DestroyGrp(HANDLE hGrp)\r
 178 {\r
 179         if (!hGrp || hGrp==INVALID_HANDLE_VALUE) return FALSE;\r
 180         VirtualFree(hGrp,0,MEM_RELEASE);\r
 181         return TRUE;\r
 182 }\r
 183 \r
 184 BOOL GRPAPI WINAPI DrawGrp(HANDLE hGrp, HDC hdcDest, int nXDest, int nYDest, WORD nFrame, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
 185 {\r
 186         if (!hGrp || hGrp==INVALID_HANDLE_VALUE || hdcDest==0 || !dwPalette) return FALSE;\r
 187         GRPHEADER *GrpFile = (GRPHEADER *)hGrp;\r
 188         nFrame %= GrpFile->nFrames;\r
 189         FRAMEHEADER *GrpFrame = &((FRAMEHEADER *)(((char *)GrpFile)+6))[nFrame];\r
 190         FRAMEHEADER *GrpFrames = &((FRAMEHEADER *)(((char *)GrpFile)+6))[0];\r
 191         int FrameSize = 0xFFFFFF;\r
 192         DWORD Right,Bottom;\r
 193         if (dwFlags&HORIZONTAL_FLIP) Right = nXDest+GrpFile->wMaxWidth-1-GrpFrame->Left;\r
 194         if (dwFlags&VERTICAL_FLIP) Bottom = nYDest+GrpFile->wMaxHeight-1-GrpFrame->Top;\r
 195         nXDest += GrpFrame->Left;\r
 196         nYDest += GrpFrame->Top;\r
 197         WORD *GrpOffsets = ((WORD *)(((char *)GrpFile)+GrpFrame->Offset));\r
 198         BYTE *GrpRaw = (BYTE *)GrpOffsets;\r
 199         BYTE *RowData;\r
 200         WORD x,ofs;\r
 201         DWORD y;\r
 202         WORD i;\r
 203         int j;\r
 204         if (nFrame + 1 < GrpFile->nFrames) {\r
 205                 for (i = 0; i + 1 < GrpFile->nFrames; i++) {\r
 206                         j = GrpFrames[i].Offset - GrpFrame->Offset;\r
 207                         if (j > 0 && j < FrameSize)\r
 208                                 FrameSize = j;\r
 209                 }\r
 210         }\r
 211         if (FrameSize == 0xFFFFFF) {\r
 212                 for (i = 0; i + 1 < GrpFile->nFrames; i++) {\r
 213                         j = GrpFrames[i].Offset - GrpFrames[0].Offset;\r
 214                         if (j > 0 && j < FrameSize)\r
 215                                 FrameSize = j;\r
 216                 }\r
 217                 if (FrameSize == GrpFrames[0].Width * GrpFrames[0].Height)\r
 218                         FrameSize = GrpFrame->Width * GrpFrame->Height;\r
 219         }\r
 220         if (!(dwFlags&HORIZONTAL_FLIP) && !(dwFlags&VERTICAL_FLIP)) {\r
 221                 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
 222                         for (y=0;y<GrpFrame->Height;y++) {\r
 223                                 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
 224                                 x=0; ofs=0;\r
 225                                 while (x<GrpFrame->Width) {\r
 226                                         if (!(RowData[ofs] & 0x80)) {\r
 227                                                 if (!(RowData[ofs] & 0x40)) {\r
 228                                                         for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
 229                                                                 SetPix(hdcDest,nXDest+x,nYDest+y,dwPalette[RowData[ofs+i]],dwFlags,dwAlpha);\r
 230                                                                 x++;\r
 231                                                         }\r
 232                                                         ofs+=RowData[ofs]+1;\r
 233                                                 }\r
 234                                                 else {\r
 235                                                         for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
 236                                                                 SetPix(hdcDest,nXDest+x,nYDest+y,dwPalette[RowData[ofs+1]],dwFlags,dwAlpha);\r
 237                                                                 x++;\r
 238                                                         }\r
 239                                                         ofs+=2;\r
 240                                                 }\r
 241                                         }\r
 242                                         else {\r
 243                                                 x+=RowData[ofs]-128;\r
 244                                                 ofs++;\r
 245                                         }\r
 246                                 }\r
 247                         }\r
 248                 }\r
 249                 else {\r
 250                         for (y=0;y<GrpFrame->Height;y++) {\r
 251                                 for (x=0;x<GrpFrame->Width;x++) {\r
 252                                         SetPix(hdcDest,nXDest+x,nYDest+y,dwPalette[GrpRaw[y * GrpFrame->Width + x]],dwFlags,dwAlpha);\r
 253                                 }\r
 254                         }\r
 255                 }\r
 256         }\r
 257         else if (dwFlags&HORIZONTAL_FLIP && !(dwFlags&VERTICAL_FLIP)) {\r
 258                 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
 259                         for (y=0;y<GrpFrame->Height;y++) {\r
 260                                 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
 261                                 x=0; ofs=0;\r
 262                                 while (x<GrpFrame->Width) {\r
 263                                         if (!(RowData[ofs] & 0x80)) {\r
 264                                                 if (!(RowData[ofs] & 0x40)) {\r
 265                                                         for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
 266                                                                 SetPix(hdcDest,Right-x,nYDest+y,dwPalette[RowData[ofs+i]],dwFlags,dwAlpha);\r
 267                                                                 x++;\r
 268                                                         }\r
 269                                                         ofs+=RowData[ofs]+1;\r
 270                                                 }\r
 271                                                 else {\r
 272                                                         for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
 273                                                                 SetPix(hdcDest,Right-x,nYDest+y,dwPalette[RowData[ofs+1]],dwFlags,dwAlpha);\r
 274                                                                 x++;\r
 275                                                         }\r
 276                                                         ofs+=2;\r
 277                                                 }\r
 278                                         }\r
 279                                         else {\r
 280                                                 x+=RowData[ofs]-128;\r
 281                                                 ofs++;\r
 282                                         }\r
 283                                 }\r
 284                         }\r
 285                 }\r
 286                 else {\r
 287                         for (y=0;y<GrpFrame->Height;y++) {\r
 288                                 for (x=0;x<GrpFrame->Width;x++) {\r
 289                                         SetPix(hdcDest,Right-x,nYDest+y,dwPalette[GrpRaw[y * GrpFrame->Width + x]],dwFlags,dwAlpha);\r
 290                                 }\r
 291                         }\r
 292                 }\r
 293         }\r
 294         else if (!(dwFlags&HORIZONTAL_FLIP) && dwFlags&VERTICAL_FLIP) {\r
 295                 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
 296                         for (y=0;y<GrpFrame->Height;y++) {\r
 297                                 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
 298                                 x=0; ofs=0;\r
 299                                 while (x<GrpFrame->Width) {\r
 300                                         if (!(RowData[ofs] & 0x80)) {\r
 301                                                 if (!(RowData[ofs] & 0x40)) {\r
 302                                                         for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
 303                                                                 SetPix(hdcDest,nXDest+x,Bottom-y,dwPalette[RowData[ofs+i]],dwFlags,dwAlpha);\r
 304                                                                 x++;\r
 305                                                         }\r
 306                                                         ofs+=RowData[ofs]+1;\r
 307                                                 }\r
 308                                                 else {\r
 309                                                         for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
 310                                                                 SetPix(hdcDest,nXDest+x,Bottom-y,dwPalette[RowData[ofs+1]],dwFlags,dwAlpha);\r
 311                                                                 x++;\r
 312                                                         }\r
 313                                                         ofs+=2;\r
 314                                                 }\r
 315                                         }\r
 316                                         else {\r
 317                                                 x+=RowData[ofs]-128;\r
 318                                                 ofs++;\r
 319                                         }\r
 320                                 }\r
 321                         }\r
 322                 }\r
 323                 else {\r
 324                         for (y=0;y<GrpFrame->Height;y++) {\r
 325                                 for (x=0;x<GrpFrame->Width;x++) {\r
 326                                         SetPix(hdcDest,nXDest+x,Bottom-y,dwPalette[GrpRaw[y * GrpFrame->Width + x]],dwFlags,dwAlpha);\r
 327                                 }\r
 328                         }\r
 329                 }\r
 330         }\r
 331         else {\r
 332                 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
 333                         for (y=0;y<GrpFrame->Height;y++) {\r
 334                                 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
 335                                 x=0; ofs=0;\r
 336                                 while (x<GrpFrame->Width) {\r
 337                                         if (!(RowData[ofs] & 0x80)) {\r
 338                                                 if (!(RowData[ofs] & 0x40)) {\r
 339                                                         for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
 340                                                                 SetPix(hdcDest,Right-x,Bottom-y,dwPalette[RowData[ofs+i]],dwFlags,dwAlpha);\r
 341                                                                 x++;\r
 342                                                         }\r
 343                                                         ofs+=RowData[ofs]+1;\r
 344                                                 }\r
 345                                                 else {\r
 346                                                         for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
 347                                                                 SetPix(hdcDest,Right-x,Bottom-y,dwPalette[RowData[ofs+1]],dwFlags,dwAlpha);\r
 348                                                                 x++;\r
 349                                                         }\r
 350                                                         ofs+=2;\r
 351                                                 }\r
 352                                         }\r
 353                                         else {\r
 354                                                 x+=RowData[ofs]-128;\r
 355                                                 ofs++;\r
 356                                         }\r
 357                                 }\r
 358                         }\r
 359                 }\r
 360                 else {\r
 361                         for (y=0;y<GrpFrame->Height;y++) {\r
 362                                 for (x=0;x<GrpFrame->Width;x++) {\r
 363                                         SetPix(hdcDest,Right-x,Bottom-y,dwPalette[GrpRaw[y * GrpFrame->Width + x]],dwFlags,dwAlpha);\r
 364                                 }\r
 365                         }\r
 366                 }\r
 367         }\r
 368         return TRUE;\r
 369 }\r
 370 \r
 371 BOOL GRPAPI WINAPI GetGrpInfo(HANDLE hGrp, GRPHEADER *GrpInfo)\r
 372 {\r
 373         if (!hGrp || hGrp==INVALID_HANDLE_VALUE || !GrpInfo) return FALSE;\r
 374         memcpy(GrpInfo,hGrp,6);\r
 375         return TRUE;\r
 376 }\r
 377 \r
 378 void GRPAPI WINAPI SetFunctionGetPixel(GETPIXELPROC lpGetPixelProc)\r
 379 {\r
 380         MyGetPixel = lpGetPixelProc;\r
 381 }\r
 382 \r
 383 void GRPAPI WINAPI SetFunctionSetPixel(SETPIXELPROC lpSetPixelProc)\r
 384 {\r
 385         MySetPixel = lpSetPixelProc;\r
 386 }\r
 387 \r
 388 void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD dwFlags, DWORD dwAlpha)\r
 389 {\r
 390         if (dwFlags&SHADOW_COLOR) {\r
 391                 clrColor = (dwFlags >> 8) & 0x00FFFFFF;\r
 392         }\r
 393         if (dwFlags&ALPHA_BLEND) {\r
 394                 DWORD dwColor = MyGetPixel(hDC,X,Y);\r
 395 \r
 396                 // Old alpha\r
 397                 /*((BYTE *)&dwColor)[0]*=1-((float)((BYTE *)&dwAlpha)[0]/256);\r
 398                 ((BYTE *)&dwColor)[1]*=1-((float)((BYTE *)&dwAlpha)[1]/256);\r
 399                 ((BYTE *)&dwColor)[2]*=1-((float)((BYTE *)&dwAlpha)[2]/256);\r
 400                 ((BYTE *)&clrColor)[0]*=(float)((BYTE *)&dwAlpha)[0]/256;\r
 401                 ((BYTE *)&clrColor)[1]*=(float)((BYTE *)&dwAlpha)[1]/256;\r
 402                 ((BYTE *)&clrColor)[2]*=(float)((BYTE *)&dwAlpha)[2]/256;\r
 403                 ((BYTE *)&clrColor)[0]+=((BYTE *)&dwColor)[0];\r
 404                 ((BYTE *)&clrColor)[1]+=((BYTE *)&dwColor)[1];\r
 405                 ((BYTE *)&clrColor)[2]+=((BYTE *)&dwColor)[2];*/\r
 406 \r
 407                 /* blendedcolor =\r
 408                      ( ( forecolor * ( 1 - alpha ) ) >> 8 )\r
 409                    + ( ( backcolor * ( 256 - alpha ) ) >> 8 ) */\r
 410                 ((BYTE *)&clrColor)[0] =\r
 411                         ( ( ((BYTE *)&clrColor)[0] * ( ((BYTE *)&dwAlpha)[0] + 1 ) ) >> 8 )\r
 412                         + ( ( ((BYTE *)&dwColor)[0] * ( 256 - ((BYTE *)&dwAlpha)[0] ) ) >> 8 );\r
 413                 ((BYTE *)&clrColor)[1] =\r
 414                         ( ( ((BYTE *)&clrColor)[1] * ( ((BYTE *)&dwAlpha)[1] + 1 ) ) >> 8 )\r
 415                         + ( ( ((BYTE *)&dwColor)[1] * ( 256 - ((BYTE *)&dwAlpha)[1] ) ) >> 8 );\r
 416                 ((BYTE *)&clrColor)[2] =\r
 417                         ( ( ((BYTE *)&clrColor)[2] * ( ((BYTE *)&dwAlpha)[2] + 1 ) ) >> 8 )\r
 418                         + ( ( ((BYTE *)&dwColor)[2] * ( 256 - ((BYTE *)&dwAlpha)[2] ) ) >> 8 );\r
 419         }\r
 420         MySetPixel(hDC,X,Y,clrColor);\r
 421 }\r