854 lines
21 KiB
C++
854 lines
21 KiB
C++
//
|
|
// Created by neo on 2019-08-15.
|
|
//
|
|
|
|
#include "../pinball.h"
|
|
|
|
//----- (01003803) --------------------------------------------------------
|
|
int grtext_draw_ttext_in_box(LPCSTR lpString, int mode, int a3, COLORREF color, int a5, int a6)
|
|
{
|
|
HDC v6; // ebx
|
|
CHAR *v7; // eax
|
|
unsigned int v8; // ax
|
|
int v9; // eax
|
|
struct tagRECT rc; // [esp+Ch] [ebp-10h]
|
|
int modea; // [esp+28h] [ebp+Ch]
|
|
COLORREF colora; // [esp+30h] [ebp+14h]
|
|
|
|
v6 = _GetDC(gdrv_hwnd);
|
|
rc.left = mode;
|
|
rc.right = color + mode;
|
|
rc.top = a3;
|
|
rc.bottom = a5 + a3;
|
|
if ( grtext_red < 0 )
|
|
{
|
|
grtext_blue = 255;
|
|
grtext_green = 255;
|
|
grtext_red = 255;
|
|
v7 = get_rc_string(189, 0);
|
|
if ( v7 )
|
|
_sscanf(v7, "%d %d %d", &grtext_red, &grtext_green, &grtext_blue);
|
|
}
|
|
modea = SetBkMode(v6, 1);
|
|
HIBYTE(v8) = grtext_blue;
|
|
LOBYTE(v8) = grtext_green;
|
|
colora = SetTextColor(v6, (unsigned __int8)grtext_red | (v8 << 8));
|
|
v9 = lstrlenA(lpString);
|
|
DrawTextA(v6, lpString, v9, &rc, 0x810u);
|
|
SetBkMode(v6, modea);
|
|
SetTextColor(v6, colora);
|
|
return ReleaseDC(gdrv_hwnd, v6);
|
|
}
|
|
// 1023050: using guessed type int grtext_red;
|
|
// 1028290: using guessed type int grtext_blue;
|
|
// 1028294: using guessed type int grtext_green;
|
|
|
|
|
|
|
|
//----- (01004154) --------------------------------------------------------
|
|
int DibSetUsage(int a1, HPALETTE hpal, int a3)
|
|
{
|
|
signed int v4; // edi
|
|
unsigned int v5; // cx
|
|
char *v6; // esi
|
|
signed int i; // eax
|
|
_BYTE *v8; // eax
|
|
BYTE v9; // bl
|
|
struct tagPALETTEENTRY pPalEntries[256]; // [esp+4h] [ebp-400h]
|
|
HPALETTE hpala; // [esp+410h] [ebp+Ch]
|
|
|
|
if ( !hpal )
|
|
hpal = (HPALETTE)GetStockObject(15);
|
|
if ( !a1 )
|
|
return 0;
|
|
v4 = *(DWORD *)(a1 + 32);
|
|
if ( !v4 )
|
|
{
|
|
v5 = *(WORD *)(a1 + 14);
|
|
if ( v5 <= 8u )
|
|
v4 = 1 << v5;
|
|
}
|
|
if ( v4 == 3 )
|
|
{
|
|
if ( *(DWORD *)(a1 + 16) != 3 )
|
|
{
|
|
LABEL_12:
|
|
v6 = (char *)(a1 + *(DWORD *)a1);
|
|
if ( (unsigned int)a3 <= 0 || (unsigned int)a3 > 2 )
|
|
{
|
|
if ( v4 >= 256 )
|
|
v4 = 256;
|
|
GetPaletteEntries(hpal, 0, v4, pPalEntries);
|
|
hpala = 0;
|
|
if ( v4 > 0 )
|
|
{
|
|
v8 = v6 + 1;
|
|
do
|
|
{
|
|
v9 = pPalEntries[(DWORD)hpala].peRed;
|
|
hpala = (HPALETTE)((char *)hpala + 1);
|
|
v8[1] = v9;
|
|
*v8 = v8[(char *)pPalEntries - v6];
|
|
*(v8 - 1) = v8[&pPalEntries[0].peGreen - (BYTE *)v6];
|
|
v8[2] = 0;
|
|
v8 += 4;
|
|
}
|
|
while ( (signed int)hpala < v4 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0; i < v4; v6 += 2 )
|
|
*(WORD *)v6 = i++;
|
|
}
|
|
return 1;
|
|
}
|
|
v4 = 0;
|
|
}
|
|
if ( v4 > 0 )
|
|
goto LABEL_12;
|
|
return 1;
|
|
}
|
|
// 1004154: using guessed type struct tagPALETTEENTRY pPalEntries[256];
|
|
|
|
//----- (0100423A) --------------------------------------------------------
|
|
DWORD *DibCreate(int a1, int a2, int a3)
|
|
{
|
|
unsigned int v3; // edi
|
|
HGLOBAL v4; // eax
|
|
DWORD *v5; // esi
|
|
DWORD *result; // eax
|
|
DWORD *i; // ecx
|
|
DWORD *v8; // ecx
|
|
int v9; // [esp+18h] [ebp+Ch]
|
|
|
|
v3 = a3 * ((a2 * a1 / 8 + 3) & 0xFFFFFFFC);
|
|
v4 = GlobalAlloc(0x42u, v3 + 1064);
|
|
v5 = GlobalLock(v4);
|
|
result = 0;
|
|
if ( v5 )
|
|
{
|
|
v5[5] = v3;
|
|
v5[1] = a2;
|
|
*v5 = 40;
|
|
v5[2] = a3;
|
|
*((WORD *)v5 + 6) = 1;
|
|
*((WORD *)v5 + 7) = a1;
|
|
v5[4] = 0;
|
|
v5[6] = 0;
|
|
v5[7] = 0;
|
|
v5[8] = 0;
|
|
v5[9] = 0;
|
|
if ( a1 == 4 )
|
|
{
|
|
v5[8] = 16;
|
|
}
|
|
else if ( a1 == 8 )
|
|
{
|
|
v5[8] = 256;
|
|
}
|
|
v9 = 0;
|
|
for ( i = v5 + 10; v9 < v5[8] / 16; ++v9 )
|
|
{
|
|
*i = 0;
|
|
v8 = i + 1;
|
|
*v8 = 0x800000;
|
|
++v8;
|
|
*v8 = 0x8000;
|
|
++v8;
|
|
*v8 = 8421376;
|
|
++v8;
|
|
*v8 = 128;
|
|
++v8;
|
|
*v8 = 8388736;
|
|
++v8;
|
|
*v8 = 32896;
|
|
++v8;
|
|
*v8 = 12632256;
|
|
++v8;
|
|
*v8 = 8421504;
|
|
++v8;
|
|
*v8 = 16711680;
|
|
++v8;
|
|
*v8 = 65280;
|
|
++v8;
|
|
*v8 = 16776960;
|
|
++v8;
|
|
*v8 = 255;
|
|
++v8;
|
|
*v8 = 16711935;
|
|
++v8;
|
|
*v8 = 0xFFFF;
|
|
++v8;
|
|
*v8 = 0xFFFFFF;
|
|
i = v8 + 1;
|
|
}
|
|
result = v5;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (01004380) --------------------------------------------------------
|
|
int gdrv_init(int a1, HWND a2)
|
|
{
|
|
gdrv_hinst = a1;
|
|
gdrv_hwnd = a2;
|
|
if ( !gdrv_palette_handle )
|
|
gdrv_palette_handle = CreatePalette(¤t_palette);
|
|
return 0;
|
|
}
|
|
// 1028284: using guessed type int gdrv_hinst;
|
|
|
|
//----- (010043B9) --------------------------------------------------------
|
|
int gdrv_display_palette(int a1)
|
|
{
|
|
HWND v1; // eax
|
|
HDC v2; // eax
|
|
HDC v3; // ebx
|
|
HPALETTE v4; // edi
|
|
BYTE *v5; // eax
|
|
int v6; // ecx
|
|
BYTE *v7; // eax
|
|
HWND v8; // eax
|
|
HDC v10; // [esp+0h] [ebp-14h]
|
|
signed int v11; // [esp+4h] [ebp-10h]
|
|
char *v12; // [esp+1Ch] [ebp+8h]
|
|
|
|
if ( gdrv_palette_handle )
|
|
DeleteObject(gdrv_palette_handle);
|
|
gdrv_palette_handle = CreatePalette(¤t_palette);
|
|
v1 = GetDesktopWindow();
|
|
v2 = _GetDC(v1);
|
|
v3 = v2;
|
|
v10 = v2;
|
|
SetSystemPaletteUse(v2, 2u);
|
|
SetSystemPaletteUse(v3, 1u);
|
|
v4 = SelectPalette(v3, (HPALETTE)gdrv_palette_handle, 0);
|
|
RealizePalette(v3);
|
|
SelectPalette(v3, v4, 0);
|
|
GetSystemPaletteEntries(v3, 0, 0x100u, &pPalEntries);
|
|
v5 = &pPalEntries.peFlags;
|
|
do
|
|
{
|
|
*v5 = 0;
|
|
v5 += 4;
|
|
}
|
|
while ( (signed int)v5 < (signed int)&unk_102345F );
|
|
v6 = a1;
|
|
v12 = (char *)&unk_102305B - a1;
|
|
v7 = (BYTE *)(v6 + 41);
|
|
v11 = 236;
|
|
do
|
|
{
|
|
if ( v6 )
|
|
{
|
|
v7[(DWORD)v12] = v7[1];
|
|
v7[(DWORD)&pPalEntries - v6] = *v7;
|
|
v7[(DWORD)((char *)&pPalEntries - v6 + 1)] = *(v7 - 1);
|
|
v3 = v10;
|
|
}
|
|
v7[(DWORD)((char *)&pPalEntries - v6 + 2)] = 4;
|
|
v7 += 4;
|
|
--v11;
|
|
}
|
|
while ( v11 );
|
|
if ( !(GetDeviceCaps(v3, 38) & 0x100) )
|
|
{
|
|
byte_102345A = -1;
|
|
byte_1023459 = -1;
|
|
byte_1023458 = -1;
|
|
}
|
|
ResizePalette((HPALETTE)gdrv_palette_handle, 0x100u);
|
|
SetPaletteEntries((HPALETTE)gdrv_palette_handle, 0, 0x100u, &pPalEntries);
|
|
v8 = GetDesktopWindow();
|
|
ReleaseDC(v8, v3);
|
|
return 0;
|
|
}
|
|
// 1023458: using guessed type char byte_1023458;
|
|
// 1023459: using guessed type char byte_1023459;
|
|
// 102345A: using guessed type char byte_102345A;
|
|
|
|
//----- (01004508) --------------------------------------------------------
|
|
int gdrv_uninit()
|
|
{
|
|
if ( gdrv_palette_handle )
|
|
DeleteObject(gdrv_palette_handle);
|
|
return 0;
|
|
}
|
|
|
|
//----- (01004520) --------------------------------------------------------
|
|
int gdrv_create_bitmap_dib(int a1, int a2, int a3)
|
|
{
|
|
int v3; // edi
|
|
DWORD *v4; // eax
|
|
DWORD *v5; // eax
|
|
int v6; // ecx
|
|
|
|
v3 = a2;
|
|
v4 = DibCreate(8, a2, a3);
|
|
*(DWORD *)a1 = v4;
|
|
DibSetUsage((int)v4, (HPALETTE)gdrv_palette_handle, 1);
|
|
*(DWORD *)(a1 + 12) = a2;
|
|
*(DWORD *)(a1 + 20) = a2;
|
|
if ( a2 % 4 )
|
|
v3 = 4 - a2 % 4 + a2;
|
|
v5 = *(DWORD **)a1;
|
|
*(DWORD *)(a1 + 20) = v3;
|
|
*(DWORD *)(a1 + 16) = a3;
|
|
*(_BYTE *)(a1 + 24) = 2;
|
|
if ( v5[4] == 3 )
|
|
v6 = (int)v5 + *v5 + 12;
|
|
else
|
|
v6 = (int)&v5[v5[8]] + *v5;
|
|
*(DWORD *)(a1 + 8) = v6;
|
|
*(DWORD *)(a1 + 4) = v6;
|
|
return 0;
|
|
}
|
|
|
|
//----- (0100459A) --------------------------------------------------------
|
|
int gdrv_create_bitmap(int a1, int a2, int a3)
|
|
{
|
|
return gdrv_create_bitmap_dib(a1, a2, a3);
|
|
}
|
|
|
|
//----- (010045AA) --------------------------------------------------------
|
|
signed int gdrv_create_raw_bitmap(int a1, int a2, int a3, int a4)
|
|
{
|
|
unsigned int v4; // ST04_4
|
|
int v5; // eax
|
|
|
|
*(DWORD *)a1 = 0;
|
|
*(DWORD *)(a1 + 12) = a2;
|
|
*(DWORD *)(a1 + 20) = a2;
|
|
if ( a4 && a2 % 4 )
|
|
*(DWORD *)(a1 + 20) = a2 - a2 % 4 + 4;
|
|
v4 = a3 * *(DWORD *)(a1 + 20);
|
|
*(DWORD *)(a1 + 16) = a3;
|
|
*(_BYTE *)(a1 + 24) = 1;
|
|
v5 = memoryallocate(v4);
|
|
*(DWORD *)(a1 + 8) = v5;
|
|
if ( !v5 )
|
|
return -1;
|
|
*(DWORD *)(a1 + 4) = v5;
|
|
return 0;
|
|
}
|
|
|
|
//----- (0100460C) --------------------------------------------------------
|
|
signed int gdrv_destroy_bitmap(int a1)
|
|
{
|
|
HGLOBAL v2; // eax
|
|
HGLOBAL v3; // eax
|
|
|
|
if ( !a1 )
|
|
return -1;
|
|
if ( *(_BYTE *)(a1 + 24) == 1 )
|
|
{
|
|
memoryfree(*(DWORD *)(a1 + 8));
|
|
}
|
|
else if ( *(_BYTE *)(a1 + 24) == 2 )
|
|
{
|
|
v2 = GlobalHandle(*(LPCVOID *)a1);
|
|
GlobalUnlock(v2);
|
|
v3 = GlobalHandle(*(LPCVOID *)a1);
|
|
GlobalFree(v3);
|
|
}
|
|
memset((void *)a1, 0, 0x24u);
|
|
*(_BYTE *)(a1 + 36) = 0;
|
|
return 0;
|
|
}
|
|
|
|
//----- (01004664) --------------------------------------------------------
|
|
UINT gdrv_start_blit_sequence()
|
|
{
|
|
HDC v0; // eax
|
|
|
|
v0 = _GetDC(gdrv_hwnd);
|
|
gdrv_sequence_handle = 0;
|
|
gdrv_sequence_hdc = v0;
|
|
SelectPalette(v0, (HPALETTE)gdrv_palette_handle, 0);
|
|
return RealizePalette(gdrv_sequence_hdc);
|
|
}
|
|
// 102828C: using guessed type int gdrv_sequence_handle;
|
|
|
|
//----- (0100469C) --------------------------------------------------------
|
|
int gdrv_blit_sequence(int a1, int xSrc, int a3, int xDest, int yDest, int DestWidth, int DestHeight)
|
|
{
|
|
int result; // eax
|
|
|
|
if ( !gdrv_use_wing )
|
|
result = StretchDIBits(
|
|
gdrv_sequence_hdc,
|
|
xDest,
|
|
yDest,
|
|
DestWidth,
|
|
DestHeight,
|
|
xSrc,
|
|
*(DWORD *)(a1 + 16) - a3 - DestHeight,
|
|
DestWidth,
|
|
DestHeight,
|
|
*(const void **)(a1 + 8),
|
|
*(const BITMAPINFO **)a1,
|
|
1u,
|
|
0xCC0020u);
|
|
return result;
|
|
}
|
|
// 1024EFC: using guessed type int gdrv_use_wing;
|
|
|
|
//----- (010046ED) --------------------------------------------------------
|
|
int gdrv_end_blit_sequence()
|
|
{
|
|
return ReleaseDC(gdrv_hwnd, gdrv_sequence_hdc);
|
|
}
|
|
|
|
//----- (01004705) --------------------------------------------------------
|
|
HDC gdrv_blit(int a1, int xSrc, int a3, int xDest, int yDest, int DestWidth, int DestHeight)
|
|
{
|
|
HDC result; // eax
|
|
HDC v8; // esi
|
|
|
|
result = _GetDC(gdrv_hwnd);
|
|
v8 = result;
|
|
if ( result )
|
|
{
|
|
SelectPalette(result, (HPALETTE)gdrv_palette_handle, 0);
|
|
RealizePalette(v8);
|
|
if ( !gdrv_use_wing )
|
|
StretchDIBits(
|
|
v8,
|
|
xDest,
|
|
yDest,
|
|
DestWidth,
|
|
DestHeight,
|
|
xSrc,
|
|
*(DWORD *)(a1 + 16) - a3 - DestHeight,
|
|
DestWidth,
|
|
DestHeight,
|
|
*(const void **)(a1 + 8),
|
|
*(const BITMAPINFO **)a1,
|
|
1u,
|
|
0xCC0020u);
|
|
result = (HDC)ReleaseDC(gdrv_hwnd, v8);
|
|
}
|
|
return result;
|
|
}
|
|
// 1024EFC: using guessed type int gdrv_use_wing;
|
|
|
|
//----- (01004787) --------------------------------------------------------
|
|
int gdrv_blat(int a1, int xDest, int yDest)
|
|
{
|
|
HDC v3; // edi
|
|
|
|
v3 = _GetDC(gdrv_hwnd);
|
|
SelectPalette(v3, (HPALETTE)gdrv_palette_handle, 0);
|
|
RealizePalette(v3);
|
|
if ( !gdrv_use_wing )
|
|
StretchDIBits(
|
|
v3,
|
|
xDest,
|
|
yDest,
|
|
*(DWORD *)(a1 + 12),
|
|
*(DWORD *)(a1 + 16),
|
|
0,
|
|
0,
|
|
*(DWORD *)(a1 + 12),
|
|
*(DWORD *)(a1 + 16),
|
|
*(const void **)(a1 + 8),
|
|
*(const BITMAPINFO **)a1,
|
|
1u,
|
|
0xCC0020u);
|
|
return ReleaseDC(gdrv_hwnd, v3);
|
|
}
|
|
// 1024EFC: using guessed type int gdrv_use_wing;
|
|
|
|
//----- (010047FA) --------------------------------------------------------
|
|
int gdrv_fill_bitmap(int a1, DWORD *a2, unsigned int a3, int a4, int a5, int a6, char a7)
|
|
{
|
|
DWORD *v7; // esi
|
|
int v8; // eax
|
|
int result; // eax
|
|
unsigned int v10; // ecx
|
|
char v11; // dl
|
|
unsigned int v12; // ecx
|
|
int v13; // eax
|
|
char *v14; // [esp+Ch] [ebp+8h]
|
|
|
|
v7 = a2;
|
|
v8 = a2[4];
|
|
if ( v8 < 0 )
|
|
v8 = -v8;
|
|
result = a5 + a2[2] + a2[3] * (v8 - a4 - a6);
|
|
v14 = (char *)result;
|
|
if ( a4 > 0 )
|
|
{
|
|
v10 = a3;
|
|
do
|
|
{
|
|
if ( (signed int)v10 > 0 )
|
|
{
|
|
LOBYTE(a1) = a7;
|
|
BYTE1(a1) = a7;
|
|
v11 = v10;
|
|
v12 = v10 >> 2;
|
|
v13 = a1 << 16;
|
|
LOWORD(v13) = a1;
|
|
memset32(v14, v13, v12);
|
|
memset(&v14[4 * v12], a7, v11 & 3);
|
|
v10 = a3;
|
|
v14 += a3;
|
|
}
|
|
result = v7[5] - v10;
|
|
v14 += result;
|
|
--a4;
|
|
}
|
|
while ( a4 );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (01004870) --------------------------------------------------------
|
|
char *gdrv_copy_bitmap(DWORD *a1, int a2, int a3, int a4, int a5, DWORD *a6, int a7, int a8)
|
|
{
|
|
DWORD *v8; // edx
|
|
int v9; // ecx
|
|
DWORD *v10; // esi
|
|
int v11; // eax
|
|
char *result; // eax
|
|
_BYTE *v13; // ecx
|
|
char v14; // bl
|
|
int v15; // [esp+10h] [ebp+8h]
|
|
int v16; // [esp+24h] [ebp+1Ch]
|
|
|
|
v8 = a1;
|
|
v9 = a1[4];
|
|
v10 = a6;
|
|
v11 = a6[4];
|
|
if ( v11 < 0 )
|
|
v11 = -v11;
|
|
if ( v9 < 0 )
|
|
v9 = -v9;
|
|
result = (char *)(a7 + a6[2] + a6[5] * (v11 - a3 - a8));
|
|
v13 = (_BYTE *)(a4 + a1[2] + a1[5] * (v9 - a3 - a5));
|
|
if ( a3 > 0 )
|
|
{
|
|
v16 = a3;
|
|
do
|
|
{
|
|
if ( a2 > 0 )
|
|
{
|
|
v15 = a2;
|
|
do
|
|
{
|
|
v14 = *result++;
|
|
*v13++ = v14;
|
|
--v15;
|
|
}
|
|
while ( v15 );
|
|
}
|
|
result += v10[5] - a2;
|
|
v13 += v8[5] - a2;
|
|
--v16;
|
|
}
|
|
while ( v16 );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (010048EC) --------------------------------------------------------
|
|
_BYTE *gdrv_copy_bitmap_w_transparency(DWORD *a1, int a2, int a3, int a4, int a5, DWORD *a6, int a7, int a8)
|
|
{
|
|
DWORD *v8; // edx
|
|
int v9; // ecx
|
|
DWORD *v10; // esi
|
|
int v11; // eax
|
|
_BYTE *result; // eax
|
|
_BYTE *v13; // ecx
|
|
int v14; // [esp+10h] [ebp+8h]
|
|
int v15; // [esp+24h] [ebp+1Ch]
|
|
|
|
v8 = a1;
|
|
v9 = a1[4];
|
|
v10 = a6;
|
|
v11 = a6[4];
|
|
if ( v11 < 0 )
|
|
v11 = -v11;
|
|
if ( v9 < 0 )
|
|
v9 = -v9;
|
|
result = (_BYTE *)(a7 + a6[2] + a6[5] * (v11 - a3 - a8));
|
|
v13 = (_BYTE *)(a4 + a1[2] + a1[5] * (v9 - a3 - a5));
|
|
if ( a3 > 0 )
|
|
{
|
|
v15 = a3;
|
|
do
|
|
{
|
|
if ( a2 > 0 )
|
|
{
|
|
v14 = a2;
|
|
do
|
|
{
|
|
if ( *result )
|
|
*v13 = *result;
|
|
++result;
|
|
++v13;
|
|
--v14;
|
|
}
|
|
while ( v14 );
|
|
}
|
|
result += v10[5] - a2;
|
|
v13 += v8[5] - a2;
|
|
--v15;
|
|
}
|
|
while ( v15 );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
//----- (01003F10) --------------------------------------------------------
|
|
HBRUSH sub_1003F10(LONG a1, LONG a2, int a3, int a4)
|
|
{
|
|
HBRUSH result; // eax
|
|
HDC v5; // esi
|
|
RECT rc; // [esp+0h] [ebp-18h]
|
|
HGDIOBJ v7; // [esp+10h] [ebp-8h]
|
|
HGDIOBJ h; // [esp+14h] [ebp-4h]
|
|
|
|
result = CreateSolidBrush(0);
|
|
h = result;
|
|
if ( result )
|
|
{
|
|
v5 = _GetDC(hWnd);
|
|
v7 = SelectObject(v5, h);
|
|
if ( v5 )
|
|
{
|
|
rc.right = a3 + a1 + 1;
|
|
rc.bottom = a4 + a2 + 1;
|
|
rc.left = a1;
|
|
rc.top = a2;
|
|
FillRect(v5, &rc, (HBRUSH)h);
|
|
ReleaseDC(hWnd, v5);
|
|
}
|
|
SelectObject(v5, v7);
|
|
result = (HBRUSH)DeleteObject(h);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (0100496C) --------------------------------------------------------
|
|
int zdrv_pad(int a1)
|
|
{
|
|
int result; // eax
|
|
|
|
result = a1;
|
|
if ( a1 & 3 )
|
|
result = a1 - (a1 & 3) + 4;
|
|
return result;
|
|
}
|
|
|
|
//----- (01004989) --------------------------------------------------------
|
|
signed int zdrv_create_zmap(int a1, int a2, int a3)
|
|
{
|
|
int v3; // ax
|
|
int v4; // eax
|
|
|
|
v3 = zdrv_pad(a2);
|
|
*(WORD *)(a1 + 4) = v3;
|
|
v4 = memoryallocate(2 * a3 * v3);
|
|
*(DWORD *)(a1 + 6) = v4;
|
|
if ( !v4 )
|
|
return -1;
|
|
*(DWORD *)(a1 + 10) = v4;
|
|
*(WORD *)a1 = a2;
|
|
*(WORD *)(a1 + 2) = a3;
|
|
return 0;
|
|
}
|
|
|
|
//----- (010049D6) --------------------------------------------------------
|
|
signed int zdrv_destroy_zmap(DWORD *a1)
|
|
{
|
|
int v2; // edi
|
|
|
|
if ( !a1 )
|
|
return -1;
|
|
if ( *(DWORD *)((char *)a1 + 6) )
|
|
memoryfree(*(DWORD *)((char *)a1 + 6));
|
|
*a1 = 0;
|
|
a1[1] = 0;
|
|
v2 = (int)(a1 + 2);
|
|
*(DWORD *)v2 = 0;
|
|
*(WORD *)(v2 + 4) = 0;
|
|
return 0;
|
|
}
|
|
|
|
//----- (01004A08) --------------------------------------------------------
|
|
int zdrv_fill(int a1, int a2, unsigned int a3, int a4, int a5, int a6, int a7)
|
|
{
|
|
int result; // eax
|
|
int v8; // esi
|
|
char *v9; // edx
|
|
unsigned int v10; // ecx
|
|
unsigned __int8 v11; // cf
|
|
unsigned int v12; // ecx
|
|
char *v13; // edi
|
|
int i; // ecx
|
|
bool v15; // zf
|
|
int v16; // [esp+Ch] [ebp+8h]
|
|
|
|
result = a4;
|
|
v8 = a2;
|
|
v9 = (char *)(*(DWORD *)(a2 + 6) + 2 * (a5 + *(signed int *)(a2 + 4) * (*(signed int *)(a2 + 2) - a4 - a6)));
|
|
if ( a4 > 0 )
|
|
{
|
|
v10 = a3;
|
|
v16 = a4;
|
|
do
|
|
{
|
|
if ( (signed int)v10 > 0 )
|
|
{
|
|
LOWORD(a1) = a7;
|
|
a1 <<= 16;
|
|
LOWORD(a1) = a7;
|
|
v11 = v10 & 1;
|
|
v12 = v10 >> 1;
|
|
memset32(v9, a1, v12);
|
|
v13 = &v9[4 * v12];
|
|
for ( i = v11; i; --i )
|
|
{
|
|
*(WORD *)v13 = a7;
|
|
v13 += 2;
|
|
}
|
|
v10 = a3;
|
|
v9 += 2 * a3;
|
|
}
|
|
result = *(signed int *)(v8 + 4) - v10;
|
|
v15 = v16-- == 1;
|
|
v9 += 2 * result;
|
|
}
|
|
while ( !v15 );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (01004A76) --------------------------------------------------------
|
|
WORD *zdrv_paint(int a1, int a2, DWORD *a3, int a4, int a5, int a6, int a7, int a8, DWORD *a9, int a10, int a11, int a12, int a13, int a14)
|
|
{
|
|
int v14; // ecx
|
|
DWORD *v15; // ebx
|
|
int v16; // eax
|
|
WORD *v17; // edi
|
|
WORD *result; // eax
|
|
bool v19; // zf
|
|
int v20; // [esp+18h] [ebp+Ch]
|
|
int v21; // [esp+24h] [ebp+18h]
|
|
_BYTE *v22; // [esp+38h] [ebp+2Ch]
|
|
_BYTE *v23; // [esp+3Ch] [ebp+30h]
|
|
|
|
v14 = a3[4];
|
|
v15 = a9;
|
|
v16 = a9[4];
|
|
if ( v16 < 0 )
|
|
v16 = -v16;
|
|
if ( v14 < 0 )
|
|
v14 = -v14;
|
|
v23 = (_BYTE *)(a10 + a9[2] + a9[5] * (v16 - a2 - a11));
|
|
v22 = (_BYTE *)(a4 + a3[2] + a3[5] * (v14 - a2 - a5));
|
|
v17 = (WORD *)(*(DWORD *)(a12 + 6)
|
|
+ 2 * (a13 + *(signed int *)(a12 + 4) * (*(signed int *)(a12 + 2) - a2 - a14)));
|
|
result = (WORD *)(*(DWORD *)(a6 + 6)
|
|
+ 2 * (a7 + *(signed int *)(a6 + 4) * (*(signed int *)(a6 + 2) - a2 - a8)));
|
|
if ( a2 )
|
|
{
|
|
v21 = a2;
|
|
while ( 1 )
|
|
{
|
|
if ( a1 )
|
|
{
|
|
v20 = a1;
|
|
do
|
|
{
|
|
if ( *result >= *v17 )
|
|
{
|
|
*v22 = *v23;
|
|
v15 = a9;
|
|
*result = *v17;
|
|
}
|
|
++v23;
|
|
++v22;
|
|
++v17;
|
|
++result;
|
|
--v20;
|
|
}
|
|
while ( v20 );
|
|
}
|
|
v23 += v15[5] - a1;
|
|
v22 += a3[5] - a1;
|
|
v17 += *(signed int *)(a12 + 4) - a1;
|
|
v19 = v21-- == 1;
|
|
result += *(signed int *)(a6 + 4) - a1;
|
|
if ( v19 )
|
|
break;
|
|
v15 = a9;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (01004B75) --------------------------------------------------------
|
|
unsigned int *zdrv_paint_flat(int a1, int a2, DWORD *a3, int a4, int a5, int a6, int a7, int a8, DWORD *a9, int a10, int a11, unsigned int a12)
|
|
{
|
|
DWORD *v12; // esi
|
|
int v13; // ecx
|
|
DWORD *v14; // edi
|
|
int v15; // eax
|
|
int v16; // ecx
|
|
unsigned int *result; // eax
|
|
bool v18; // zf
|
|
int v19; // [esp+18h] [ebp+Ch]
|
|
_BYTE *v20; // [esp+1Ch] [ebp+10h]
|
|
_BYTE *v21; // [esp+34h] [ebp+28h]
|
|
int v22; // [esp+3Ch] [ebp+30h]
|
|
|
|
v12 = a3;
|
|
v13 = a3[4];
|
|
v14 = a9;
|
|
v15 = a9[4];
|
|
if ( v15 < 0 )
|
|
v15 = -v15;
|
|
if ( v13 < 0 )
|
|
v13 = -v13;
|
|
v16 = a3[2] + a3[5] * (v13 - a2 - a5);
|
|
v20 = (_BYTE *)(a10 + a9[2] + a9[5] * (v15 - a2 - a11));
|
|
v21 = (_BYTE *)(a4 + v16);
|
|
result = (unsigned int *)(*(DWORD *)(a6 + 6)
|
|
+ 2 * (a7 + *(signed int *)(a6 + 4) * (*(signed int *)(a6 + 2) - a2 - a8)));
|
|
if ( a2 > 0 )
|
|
{
|
|
v22 = a2;
|
|
do
|
|
{
|
|
if ( a1 > 0 )
|
|
{
|
|
v19 = a1;
|
|
do
|
|
{
|
|
if ( *v20 )
|
|
{
|
|
if ( *result > a12 )
|
|
*v21 = *v20;
|
|
}
|
|
++v20;
|
|
++v21;
|
|
++result;
|
|
--v19;
|
|
}
|
|
while ( v19 );
|
|
}
|
|
v20 += v14[5] - a1;
|
|
v21 += v12[5] - a1;
|
|
v18 = v22-- == 1;
|
|
result += *(signed int *)(a6 + 4) - a1;
|
|
}
|
|
while ( !v18 );
|
|
}
|
|
return result;
|
|
}
|