sydney/3d-pinball-space-cadet
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clean up extra decorators

Browse Source
This commit is contained in:
Sydney Biscuit committed 2019-08-18 16:44:11 -07:00
1 parent 531e638179
commit 3183e73860
95 files changed
+4629 -4631
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

graphics/flasher.cpp
+13 -13
View File
@@ -5,32 +5,32 @@
#include "../pinball.h"
//----- (01009910) --------------------------------------------------------
void __stdcall flasher_callback(int a1, void *a2)
void flasher_callback(int a1, void *a2)
{
int v2; // eax
v2 = 1 - *((_DWORD *)a2 + 8);
*((_DWORD *)a2 + 8) = v2;
render_sprite_set_bitmap(*(_DWORD **)a2, *((_DWORD *)a2 + v2 + 1));
*((_DWORD *)a2 + 7) = timer_set(*((float *)a2 + *((_DWORD *)a2 + 8) + 5), (int)a2, (int)flasher_callback);
v2 = 1 - *((DWORD *)a2 + 8);
*((DWORD *)a2 + 8) = v2;
render_sprite_set_bitmap(*(DWORD **)a2, *((DWORD *)a2 + v2 + 1));
*((DWORD *)a2 + 7) = timer_set(*((float *)a2 + *((DWORD *)a2 + 8) + 5), (int)a2, (int)flasher_callback);
}
//----- (01009950) --------------------------------------------------------
void __stdcall flasher_start(struct flasher_type *a1, int a2)
void flasher_start(struct flasher_type *a1, int a2)
{
*((_DWORD *)a1 + 8) = a2;
*((DWORD *)a1 + 8) = a2;
flasher_callback(0, (void *)a1);
}
//----- (0100996F) --------------------------------------------------------
void __stdcall flasher_stop(struct flasher_type *a1, int a2)
void flasher_stop(struct flasher_type *a1, int a2)
{
if ( *((_DWORD *)a1 + 7) )
timer_kill(*((_DWORD *)a1 + 7));
*((_DWORD *)a1 + 7) = 0;
if ( *((DWORD *)a1 + 7) )
timer_kill(*((DWORD *)a1 + 7));
*((DWORD *)a1 + 7) = 0;
if ( a2 >= 0 )
{
*((_DWORD *)a1 + 8) = a2;
render_sprite_set_bitmap(*(_DWORD **)a1, *((_DWORD *)a1 + a2 + 1));
*((DWORD *)a1 + 8) = a2;
render_sprite_set_bitmap(*(DWORD **)a1, *((DWORD *)a1 + a2 + 1));
}
}
graphics/fullscreen.cpp
+12 -12
View File
@@ -55,7 +55,7 @@ LONG sub_100399D()
}
//----- (010039C5) --------------------------------------------------------
BOOL __stdcall fullscrn_set_menu_mode(int a1)
BOOL fullscrn_set_menu_mode(int a1)
{
BOOL result; // eax
@@ -145,7 +145,7 @@ int sub_1003B66()
// 1024EF4: using guessed type int fullscrn_display_changed;
//----- (01003BE4) --------------------------------------------------------
LONG __stdcall fullscrn_set_screen_mode(int a1)
LONG fullscrn_set_screen_mode(int a1)
{
LONG result; // eax
@@ -178,14 +178,14 @@ LONG __stdcall fullscrn_set_screen_mode(int a1)
// 1024EEC: using guessed type int dword_1024EEC;
//----- (01003C87) --------------------------------------------------------
void __stdcall fullscrn_force_redraw()
void fullscrn_force_redraw()
{
BYTE1(dword_1024EEC) |= 0x80u;
}
// 1024EEC: using guessed type int dword_1024EEC;
//----- (01003C94) --------------------------------------------------------
signed int __stdcall fullscrn_displaychange()
signed int fullscrn_displaychange()
{
signed int v0; // esi
signed int result; // eax
@@ -228,7 +228,7 @@ signed int __stdcall fullscrn_displaychange()
// 1024EF4: using guessed type int fullscrn_display_changed;
//----- (01003D65) --------------------------------------------------------
BOOL __stdcall fullscrn_init(int a1, int a2, int a3, HWND a4, int a5, int a6)
BOOL fullscrn_init(int a1, int a2, int a3, HWND a4, int a5, int a6)
{
HWND v6; // eax
int v7; // ebx
@@ -269,7 +269,7 @@ BOOL __stdcall fullscrn_init(int a1, int a2, int a3, HWND a4, int a5, int a6)
// 1024EF8: using guessed type int dword_1024EF8;
//----- (01003E53) --------------------------------------------------------
LONG __stdcall fullscrn_shutdown()
LONG fullscrn_shutdown()
{
LONG result; // eax
@@ -280,7 +280,7 @@ LONG __stdcall fullscrn_shutdown()
// 1024EF4: using guessed type int fullscrn_display_changed;
//----- (01003E69) --------------------------------------------------------
BOOL __stdcall fullscrn_activate(int a1)
BOOL fullscrn_activate(int a1)
{
BOOL result; // eax
@@ -297,15 +297,15 @@ BOOL __stdcall fullscrn_activate(int a1)
// 1024EE4: using guessed type int fullscrn_screen_mode;
//----- (01003EA2) --------------------------------------------------------
int __stdcall fullscrn_convert_mouse_pos(int a1)
int fullscrn_convert_mouse_pos(int a1)
{
return (unsigned __int16)(a1 - xDest) | ((unsigned __int16)(HIWORD(a1) - yDest) << 16);
return (unsigned int)(a1 - xDest) | ((unsigned int)(HIWORD(a1) - yDest) << 16);
}
//----- (01003ECF) --------------------------------------------------------
_DWORD *__stdcall fullscrn_getminmaxinfo(_DWORD *a1)
DWORD *fullscrn_getminmaxinfo(DWORD *a1)
{
_DWORD *result; // eax
DWORD *result; // eax
result = a1;
a1[2] = X.right - X.left;
@@ -316,7 +316,7 @@ _DWORD *__stdcall fullscrn_getminmaxinfo(_DWORD *a1)
}
//----- (01003F98) --------------------------------------------------------
void __stdcall fullscrn_paint()
void fullscrn_paint()
{
int v0; // ST04_4
int v1; // eax
graphics/graphics.cpp
+101 -101
View File
@@ -5,11 +5,11 @@
#include "../pinball.h"
//----- (01003803) --------------------------------------------------------
int __stdcall grtext_draw_ttext_in_box(LPCSTR lpString, int mode, int a3, COLORREF color, int a5, int a6)
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 __int16 v8; // ax
unsigned int v8; // ax
int v9; // eax
struct tagRECT rc; // [esp+Ch] [ebp-10h]
int modea; // [esp+28h] [ebp+Ch]
@@ -46,10 +46,10 @@ int __stdcall grtext_draw_ttext_in_box(LPCSTR lpString, int mode, int a3, COLORR
//----- (01004154) --------------------------------------------------------
int __stdcall DibSetUsage(int a1, HPALETTE hpal, int a3)
int DibSetUsage(int a1, HPALETTE hpal, int a3)
{
signed int v4; // edi
unsigned __int16 v5; // cx
unsigned int v5; // cx
char *v6; // esi
signed int i; // eax
_BYTE *v8; // eax
@@ -61,19 +61,19 @@ int __stdcall DibSetUsage(int a1, HPALETTE hpal, int a3)
hpal = (HPALETTE)GetStockObject(15);
if ( !a1 )
return 0;
v4 = *(_DWORD *)(a1 + 32);
v4 = *(DWORD *)(a1 + 32);
if ( !v4 )
{
v5 = *(_WORD *)(a1 + 14);
v5 = *(WORD *)(a1 + 14);
if ( v5 <= 8u )
v4 = 1 << v5;
}
if ( v4 == 3 )
{
if ( *(_DWORD *)(a1 + 16) != 3 )
if ( *(DWORD *)(a1 + 16) != 3 )
{
LABEL_12:
v6 = (char *)(a1 + *(_DWORD *)a1);
v6 = (char *)(a1 + *(DWORD *)a1);
if ( (unsigned int)a3 <= 0 || (unsigned int)a3 > 2 )
{
if ( v4 >= 256 )
@@ -85,7 +85,7 @@ int __stdcall DibSetUsage(int a1, HPALETTE hpal, int a3)
v8 = v6 + 1;
do
{
v9 = pPalEntries[(_DWORD)hpala].peRed;
v9 = pPalEntries[(DWORD)hpala].peRed;
hpala = (HPALETTE)((char *)hpala + 1);
v8[1] = v9;
*v8 = v8[(char *)pPalEntries - v6];
@@ -99,7 +99,7 @@ int __stdcall DibSetUsage(int a1, HPALETTE hpal, int a3)
else
{
for ( i = 0; i < v4; v6 += 2 )
*(_WORD *)v6 = i++;
*(WORD *)v6 = i++;
}
return 1;
}
@@ -112,14 +112,14 @@ int __stdcall DibSetUsage(int a1, HPALETTE hpal, int a3)
// 1004154: using guessed type struct tagPALETTEENTRY pPalEntries[256];
//----- (0100423A) --------------------------------------------------------
_DWORD *__stdcall DibCreate(int a1, int a2, int a3)
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
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);
@@ -132,8 +132,8 @@ _DWORD *__stdcall DibCreate(int a1, int a2, int a3)
v5[1] = a2;
*v5 = 40;
v5[2] = a3;
*((_WORD *)v5 + 6) = 1;
*((_WORD *)v5 + 7) = a1;
*((WORD *)v5 + 6) = 1;
*((WORD *)v5 + 7) = a1;
v5[4] = 0;
v5[6] = 0;
v5[7] = 0;
@@ -189,7 +189,7 @@ _DWORD *__stdcall DibCreate(int a1, int a2, int a3)
}
//----- (01004380) --------------------------------------------------------
int __stdcall gdrv_init(int a1, HWND a2)
int gdrv_init(int a1, HWND a2)
{
gdrv_hinst = a1;
gdrv_hwnd = a2;
@@ -200,7 +200,7 @@ int __stdcall gdrv_init(int a1, HWND a2)
// 1028284: using guessed type int gdrv_hinst;
//----- (010043B9) --------------------------------------------------------
int __stdcall gdrv_display_palette(int a1)
int gdrv_display_palette(int a1)
{
HWND v1; // eax
HDC v2; // eax
@@ -242,12 +242,12 @@ int __stdcall gdrv_display_palette(int a1)
{
if ( v6 )
{
v7[(_DWORD)v12] = v7[1];
v7[(_DWORD)&pPalEntries - v6] = *v7;
v7[(_DWORD)((char *)&pPalEntries - v6 + 1)] = *(v7 - 1);
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[(DWORD)((char *)&pPalEntries - v6 + 2)] = 4;
v7 += 4;
--v11;
}
@@ -269,7 +269,7 @@ int __stdcall gdrv_display_palette(int a1)
// 102345A: using guessed type char byte_102345A;
//----- (01004508) --------------------------------------------------------
int __stdcall gdrv_uninit()
int gdrv_uninit()
{
if ( gdrv_palette_handle )
DeleteObject(gdrv_palette_handle);
@@ -277,64 +277,64 @@ int __stdcall gdrv_uninit()
}
//----- (01004520) --------------------------------------------------------
int __stdcall gdrv_create_bitmap_dib(int a1, int a2, int a3)
int gdrv_create_bitmap_dib(int a1, int a2, int a3)
{
int v3; // edi
_DWORD *v4; // eax
_DWORD *v5; // eax
DWORD *v4; // eax
DWORD *v5; // eax
int v6; // ecx
v3 = a2;
v4 = DibCreate(8, a2, a3);
*(_DWORD *)a1 = v4;
*(DWORD *)a1 = v4;
DibSetUsage((int)v4, (HPALETTE)gdrv_palette_handle, 1);
*(_DWORD *)(a1 + 12) = a2;
*(_DWORD *)(a1 + 20) = a2;
*(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;
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;
*(DWORD *)(a1 + 8) = v6;
*(DWORD *)(a1 + 4) = v6;
return 0;
}
//----- (0100459A) --------------------------------------------------------
int __stdcall gdrv_create_bitmap(int a1, int a2, int a3)
int gdrv_create_bitmap(int a1, int a2, int a3)
{
return gdrv_create_bitmap_dib(a1, a2, a3);
}
//----- (010045AA) --------------------------------------------------------
signed int __stdcall gdrv_create_raw_bitmap(int a1, int a2, int a3, int a4)
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;
*(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;
*(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;
*(DWORD *)(a1 + 8) = v5;
if ( !v5 )
return -1;
*(_DWORD *)(a1 + 4) = v5;
*(DWORD *)(a1 + 4) = v5;
return 0;
}
//----- (0100460C) --------------------------------------------------------
signed int __stdcall gdrv_destroy_bitmap(int a1)
signed int gdrv_destroy_bitmap(int a1)
{
HGLOBAL v2; // eax
HGLOBAL v3; // eax
@@ -343,7 +343,7 @@ signed int __stdcall gdrv_destroy_bitmap(int a1)
return -1;
if ( *(_BYTE *)(a1 + 24) == 1 )
{
memoryfree(*(_DWORD *)(a1 + 8));
memoryfree(*(DWORD *)(a1 + 8));
}
else if ( *(_BYTE *)(a1 + 24) == 2 )
{
@@ -358,7 +358,7 @@ signed int __stdcall gdrv_destroy_bitmap(int a1)
}
//----- (01004664) --------------------------------------------------------
UINT __stdcall gdrv_start_blit_sequence()
UINT gdrv_start_blit_sequence()
{
HDC v0; // eax
@@ -371,7 +371,7 @@ UINT __stdcall gdrv_start_blit_sequence()
// 102828C: using guessed type int gdrv_sequence_handle;
//----- (0100469C) --------------------------------------------------------
int __stdcall gdrv_blit_sequence(int a1, int xSrc, int a3, int xDest, int yDest, int DestWidth, int DestHeight)
int gdrv_blit_sequence(int a1, int xSrc, int a3, int xDest, int yDest, int DestWidth, int DestHeight)
{
int result; // eax
@@ -383,7 +383,7 @@ int __stdcall gdrv_blit_sequence(int a1, int xSrc, int a3, int xDest, int yDest,
DestWidth,
DestHeight,
xSrc,
*(_DWORD *)(a1 + 16) - a3 - DestHeight,
*(DWORD *)(a1 + 16) - a3 - DestHeight,
DestWidth,
DestHeight,
*(const void **)(a1 + 8),
@@ -395,13 +395,13 @@ int __stdcall gdrv_blit_sequence(int a1, int xSrc, int a3, int xDest, int yDest,
// 1024EFC: using guessed type int gdrv_use_wing;
//----- (010046ED) --------------------------------------------------------
int __stdcall gdrv_end_blit_sequence()
int gdrv_end_blit_sequence()
{
return ReleaseDC(gdrv_hwnd, gdrv_sequence_hdc);
}
//----- (01004705) --------------------------------------------------------
HDC __stdcall gdrv_blit(int a1, int xSrc, int a3, int xDest, int yDest, int DestWidth, int DestHeight)
HDC gdrv_blit(int a1, int xSrc, int a3, int xDest, int yDest, int DestWidth, int DestHeight)
{
HDC result; // eax
HDC v8; // esi
@@ -420,7 +420,7 @@ HDC __stdcall gdrv_blit(int a1, int xSrc, int a3, int xDest, int yDest, int Dest
DestWidth,
DestHeight,
xSrc,
*(_DWORD *)(a1 + 16) - a3 - DestHeight,
*(DWORD *)(a1 + 16) - a3 - DestHeight,
DestWidth,
DestHeight,
*(const void **)(a1 + 8),
@@ -434,7 +434,7 @@ HDC __stdcall gdrv_blit(int a1, int xSrc, int a3, int xDest, int yDest, int Dest
// 1024EFC: using guessed type int gdrv_use_wing;
//----- (01004787) --------------------------------------------------------
int __stdcall gdrv_blat(int a1, int xDest, int yDest)
int gdrv_blat(int a1, int xDest, int yDest)
{
HDC v3; // edi
@@ -446,12 +446,12 @@ int __stdcall gdrv_blat(int a1, int xDest, int yDest)
v3,
xDest,
yDest,
*(_DWORD *)(a1 + 12),
*(_DWORD *)(a1 + 16),
*(DWORD *)(a1 + 12),
*(DWORD *)(a1 + 16),
0,
0,
*(_DWORD *)(a1 + 12),
*(_DWORD *)(a1 + 16),
*(DWORD *)(a1 + 12),
*(DWORD *)(a1 + 16),
*(const void **)(a1 + 8),
*(const BITMAPINFO **)a1,
1u,
@@ -461,9 +461,9 @@ int __stdcall gdrv_blat(int a1, int xDest, int yDest)
// 1024EFC: using guessed type int gdrv_use_wing;
//----- (010047FA) --------------------------------------------------------
int __userpurge gdrv_fill_bitmap@<eax>(int a1@<ebx>, _DWORD *a2, unsigned int a3, int a4, int a5, int a6, char a7)
int gdrv_fill_bitmap(int a1, DWORD *a2, unsigned int a3, int a4, int a5, int a6, char a7)
{
_DWORD *v7; // esi
DWORD *v7; // esi
int v8; // eax
int result; // eax
unsigned int v10; // ecx
@@ -506,11 +506,11 @@ return result;
}
//----- (01004870) --------------------------------------------------------
char *__stdcall gdrv_copy_bitmap(_DWORD *a1, int a2, int a3, int a4, int a5, _DWORD *a6, int a7, int a8)
char *gdrv_copy_bitmap(DWORD *a1, int a2, int a3, int a4, int a5, DWORD *a6, int a7, int a8)
{
_DWORD *v8; // edx
DWORD *v8; // edx
int v9; // ecx
_DWORD *v10; // esi
DWORD *v10; // esi
int v11; // eax
char *result; // eax
_BYTE *v13; // ecx
@@ -554,11 +554,11 @@ char *__stdcall gdrv_copy_bitmap(_DWORD *a1, int a2, int a3, int a4, int a5, _DW
}
//----- (010048EC) --------------------------------------------------------
_BYTE *__stdcall gdrv_copy_bitmap_w_transparency(_DWORD *a1, int a2, int a3, int a4, int a5, _DWORD *a6, int a7, int a8)
_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
DWORD *v8; // edx
int v9; // ecx
_DWORD *v10; // esi
DWORD *v10; // esi
int v11; // eax
_BYTE *result; // eax
_BYTE *v13; // ecx
@@ -604,7 +604,7 @@ _BYTE *__stdcall gdrv_copy_bitmap_w_transparency(_DWORD *a1, int a2, int a3, int
//----- (01003F10) --------------------------------------------------------
HBRUSH __userpurge sub_1003F10@<eax>(LONG a1@<ebx>, LONG a2@<edi>, int a3, int a4)
HBRUSH sub_1003F10(LONG a1, LONG a2, int a3, int a4)
{
HBRUSH result; // eax
HDC v5; // esi
@@ -634,7 +634,7 @@ return result;
}
//----- (0100496C) --------------------------------------------------------
int __stdcall zdrv_pad(int a1)
int zdrv_pad(int a1)
{
int result; // eax
@@ -645,42 +645,42 @@ int __stdcall zdrv_pad(int a1)
}
//----- (01004989) --------------------------------------------------------
signed int __stdcall zdrv_create_zmap(int a1, int a2, int a3)
signed int zdrv_create_zmap(int a1, int a2, int a3)
{
__int16 v3; // ax
int v3; // ax
int v4; // eax
v3 = zdrv_pad(a2);
*(_WORD *)(a1 + 4) = v3;
*(WORD *)(a1 + 4) = v3;
v4 = memoryallocate(2 * a3 * v3);
*(_DWORD *)(a1 + 6) = v4;
*(DWORD *)(a1 + 6) = v4;
if ( !v4 )
return -1;
*(_DWORD *)(a1 + 10) = v4;
*(_WORD *)a1 = a2;
*(_WORD *)(a1 + 2) = a3;
*(DWORD *)(a1 + 10) = v4;
*(WORD *)a1 = a2;
*(WORD *)(a1 + 2) = a3;
return 0;
}
//----- (010049D6) --------------------------------------------------------
signed int __stdcall zdrv_destroy_zmap(_DWORD *a1)
signed int zdrv_destroy_zmap(DWORD *a1)
{
int v2; // edi
if ( !a1 )
return -1;
if ( *(_DWORD *)((char *)a1 + 6) )
memoryfree(*(_DWORD *)((char *)a1 + 6));
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;
*(DWORD *)v2 = 0;
*(WORD *)(v2 + 4) = 0;
return 0;
}
//----- (01004A08) --------------------------------------------------------
int __userpurge zdrv_fill@<eax>(int a1@<ebx>, int a2, unsigned int a3, int a4, int a5, int a6, __int16 a7)
int zdrv_fill(int a1, int a2, unsigned int a3, int a4, int a5, int a6, int a7)
{
int result; // eax
int v8; // esi
@@ -695,7 +695,7 @@ int v16; // [esp+Ch] [ebp+8h]
result = a4;
v8 = a2;
v9 = (char *)(*(_DWORD *)(a2 + 6) + 2 * (a5 + *(signed __int16 *)(a2 + 4) * (*(signed __int16 *)(a2 + 2) - a4 - a6)));
v9 = (char *)(*(DWORD *)(a2 + 6) + 2 * (a5 + *(signed int *)(a2 + 4) * (*(signed int *)(a2 + 2) - a4 - a6)));
if ( a4 > 0 )
{
v10 = a3;
@@ -713,13 +713,13 @@ memset32(v9, a1, v12);
v13 = &v9[4 * v12];
for ( i = v11; i; --i )
{
*(_WORD *)v13 = a7;
*(WORD *)v13 = a7;
v13 += 2;
}
v10 = a3;
v9 += 2 * a3;
}
result = *(signed __int16 *)(v8 + 4) - v10;
result = *(signed int *)(v8 + 4) - v10;
v15 = v16-- == 1;
v9 += 2 * result;
}
@@ -729,13 +729,13 @@ return result;
}
//----- (01004A76) --------------------------------------------------------
_WORD *__stdcall 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)
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
DWORD *v15; // ebx
int v16; // eax
_WORD *v17; // edi
_WORD *result; // eax
WORD *v17; // edi
WORD *result; // eax
bool v19; // zf
int v20; // [esp+18h] [ebp+Ch]
int v21; // [esp+24h] [ebp+18h]
@@ -751,10 +751,10 @@ _WORD *__stdcall zdrv_paint(int a1, int a2, _DWORD *a3, int a4, int a5, int a6,
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 __int16 *)(a12 + 4) * (*(signed __int16 *)(a12 + 2) - a2 - a14)));
result = (_WORD *)(*(_DWORD *)(a6 + 6)
+ 2 * (a7 + *(signed __int16 *)(a6 + 4) * (*(signed __int16 *)(a6 + 2) - a2 - a8)));
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;
@@ -781,9 +781,9 @@ _WORD *__stdcall zdrv_paint(int a1, int a2, _DWORD *a3, int a4, int a5, int a6,
}
v23 += v15[5] - a1;
v22 += a3[5] - a1;
v17 += *(signed __int16 *)(a12 + 4) - a1;
v17 += *(signed int *)(a12 + 4) - a1;
v19 = v21-- == 1;
result += *(signed __int16 *)(a6 + 4) - a1;
result += *(signed int *)(a6 + 4) - a1;
if ( v19 )
break;
v15 = a9;
@@ -793,14 +793,14 @@ _WORD *__stdcall zdrv_paint(int a1, int a2, _DWORD *a3, int a4, int a5, int a6,
}
//----- (01004B75) --------------------------------------------------------
unsigned __int16 *__stdcall 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 __int16 a12)
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
DWORD *v12; // esi
int v13; // ecx
_DWORD *v14; // edi
DWORD *v14; // edi
int v15; // eax
int v16; // ecx
unsigned __int16 *result; // eax
unsigned int *result; // eax
bool v18; // zf
int v19; // [esp+18h] [ebp+Ch]
_BYTE *v20; // [esp+1Ch] [ebp+10h]
@@ -818,8 +818,8 @@ unsigned __int16 *__stdcall zdrv_paint_flat(int a1, int a2, _DWORD *a3, int a4,
v16 = a3[2] + a3[5] * (v13 - a2 - a5);
v20 = (_BYTE *)(a10 + a9[2] + a9[5] * (v15 - a2 - a11));
v21 = (_BYTE *)(a4 + v16);
result = (unsigned __int16 *)(*(_DWORD *)(a6 + 6)
+ 2 * (a7 + *(signed __int16 *)(a6 + 4) * (*(signed __int16 *)(a6 + 2) - a2 - a8)));
result = (unsigned int *)(*(DWORD *)(a6 + 6)
+ 2 * (a7 + *(signed int *)(a6 + 4) * (*(signed int *)(a6 + 2) - a2 - a8)));
if ( a2 > 0 )
{
v22 = a2;
@@ -845,7 +845,7 @@ unsigned __int16 *__stdcall zdrv_paint_flat(int a1, int a2, _DWORD *a3, int a4,
v20 += v14[5] - a1;
v21 += v12[5] - a1;
v18 = v22-- == 1;
result += *(signed __int16 *)(a6 + 4) - a1;
result += *(signed int *)(a6 + 4) - a1;
}
while ( !v18 );
}
graphics/render.cpp
+91 -91
View File
@@ -1,7 +1,7 @@
#include "../pinball.h"
//----- (0101304D) --------------------------------------------------------
void __stdcall render_repaint(struct render_sprite_type_struct *a1)
void render_repaint(struct render_sprite_type_struct *a1)
{
int *v1; // edi
bool v2; // zf
@@ -14,17 +14,17 @@ int v8; // [esp+14h] [ebp-4h]
struct render_sprite_type_struct *v9; // [esp+20h] [ebp+8h]
v1 = (int *)a1;
if ( *((_DWORD *)a1 + 17) )
if ( *((DWORD *)a1 + 17) )
{
v2 = *((_DWORD *)a1 + 18) == 0;
v3 = *((_DWORD *)a1 + 18) < 0;
v2 = *((DWORD *)a1 + 18) == 0;
v3 = *((DWORD *)a1 + 18) < 0;
v9 = 0;
if ( !v3 && !v2 )
{
do
{
v4 = *(_DWORD *)(v1[17] + 4 * (_DWORD)v9);
if ( !*(_BYTE *)(v4 + 24) && *(_DWORD *)(v4 + 16) )
v4 = *(DWORD *)(v1[17] + 4 * (DWORD)v9);
if ( !*(_BYTE *)(v4 + 24) && *(DWORD *)(v4 + 16) )
{
if ( rectangle_clip((int *)v4, v1 + 13, &v5) )
zdrv_paint(
@@ -36,12 +36,12 @@ v6,
(int)&zscreen,
v5,
v6,
*(_DWORD **)(v4 + 16),
v5 - *(_DWORD *)v4,
v6 - *(_DWORD *)(v4 + 4),
*(_DWORD *)(v4 + 20),
v5 + *(_DWORD *)(v4 + 44) - *(_DWORD *)v4,
v6 + *(_DWORD *)(v4 + 48) - *(_DWORD *)(v4 + 4));
*(DWORD **)(v4 + 16),
v5 - *(DWORD *)v4,
v6 - *(DWORD *)(v4 + 4),
*(DWORD *)(v4 + 20),
v5 + *(DWORD *)(v4 + 44) - *(DWORD *)v4,
v6 + *(DWORD *)(v4 + 48) - *(DWORD *)(v4 + 4));
}
v9 = (struct render_sprite_type_struct *)((char *)v9 + 1);
}
@@ -51,7 +51,7 @@ while ( (signed int)v9 < v1[18] );
}
//----- (010130F3) --------------------------------------------------------
void __stdcall render_paint_balls()
void render_paint_balls()
{
int v0; // ecx
int v1; // edi
@@ -65,7 +65,7 @@ int v8; // ebx
int v9; // ST48_4
int v10; // [esp+Ch] [ebp-10h]
struct render_sprite_type_struct **v11; // [esp+10h] [ebp-Ch]
_DWORD *v12; // [esp+14h] [ebp-8h]
DWORD *v12; // [esp+14h] [ebp-8h]
v0 = render_many_balls;
if ( render_many_balls > 1 )
@@ -79,7 +79,7 @@ for ( i = v1; i < v0 / 2; ++i )
{
v3 = render_ball_list[i];
v4 = &render_ball_list[v1];
if ( *((_WORD *)*v4 + 13) > *((_WORD *)v3 + 13) )
if ( *((WORD *)*v4 + 13) > *((WORD *)v3 + 13) )
{
v5 = *v4;
*v4 = v3;
@@ -101,7 +101,7 @@ do
{
v6 = *v11;
v7 = (int *)((char *)*v11 + 52);
if ( *((_DWORD *)*v11 + 4) && rectangle_clip((int *)v6, (int *)&vscreen_rect, (_DWORD *)*v11 + 13) )
if ( *((DWORD *)*v11 + 4) && rectangle_clip((int *)v6, (int *)&vscreen_rect, (DWORD *)*v11 + 13) )
{
v8 = *v7;
v9 = v7[1];
@@ -115,17 +115,17 @@ v9,
(int)&zscreen,
v8,
v9,
*((_DWORD **)v6 + 4),
v8 - *(_DWORD *)v6,
v9 - *((_DWORD *)v6 + 1),
*((_WORD *)v6 + 13));
*((DWORD **)v6 + 4),
v8 - *(DWORD *)v6,
v9 - *((DWORD *)v6 + 1),
*((WORD *)v6 + 13));
}
else
{
v7[2] = -1;
}
++v10;
v12 = (_DWORD *)((char *)v12 + 37);
v12 = (DWORD *)((char *)v12 + 37);
++v11;
}
while ( v10 < render_many_balls );
@@ -135,14 +135,14 @@ while ( v10 < render_many_balls );
// 1025070: using guessed type int render_many_balls;
//----- (0101320D) --------------------------------------------------------
void __stdcall render_unpaint_balls()
void render_unpaint_balls()
{
_DWORD *v0; // ebx
DWORD *v0; // ebx
struct render_sprite_type_struct *v1; // edi
_DWORD *v2; // esi
DWORD *v2; // esi
int v3; // eax
_DWORD *v4; // edi
_DWORD *v5; // esi
DWORD *v4; // edi
DWORD *v5; // esi
bool v6; // zf
int v7; // [esp+0h] [ebp-8h]
struct render_sprite_type_struct **v8; // [esp+4h] [ebp-4h]
@@ -150,17 +150,17 @@ struct render_sprite_type_struct **v8; // [esp+4h] [ebp-4h]
v8 = &render_ball_list[render_many_balls - 1];
if ( render_many_balls - 1 >= 0 )
{
v0 = (_DWORD *)((char *)&ball_bitmap + 37 * (render_many_balls - 1));
v0 = (DWORD *)((char *)&ball_bitmap + 37 * (render_many_balls - 1));
v7 = render_many_balls;
do
{
v1 = *v8;
v2 = (_DWORD *)((char *)*v8 + 52);
v3 = *((_DWORD *)*v8 + 15);
v2 = (DWORD *)((char *)*v8 + 52);
v3 = *((DWORD *)*v8 + 15);
if ( v3 > 0 )
gdrv_copy_bitmap(&vscreen, v3, *((_DWORD *)*v8 + 16), *((_DWORD *)*v8 + 13), *((_DWORD *)*v8 + 14), v0, 0, 0);
gdrv_copy_bitmap(&vscreen, v3, *((DWORD *)*v8 + 16), *((DWORD *)*v8 + 13), *((DWORD *)*v8 + 14), v0, 0, 0);
--v8;
v4 = (_DWORD *)((char *)v1 + 28);
v4 = (DWORD *)((char *)v1 + 28);
*v4 = *v2;
v5 = v2 + 1;
++v4;
@@ -168,7 +168,7 @@ v5 = v2 + 1;
++v5;
++v4;
*v4 = *v5;
v0 = (_DWORD *)((char *)v0 - 37);
v0 = (DWORD *)((char *)v0 - 37);
v6 = v7-- == 1;
v4[1] = v5[1];
}
@@ -179,7 +179,7 @@ while ( !v6 );
// 1025070: using guessed type int render_many_balls;
//----- (01013283) --------------------------------------------------------
int __stdcall render_remove_sprite(struct render_sprite_type_struct *a1)
int render_remove_sprite(struct render_sprite_type_struct *a1)
{
int v1; // eax
int v2; // ecx
@@ -200,8 +200,8 @@ v1 = render_many_sprites;
++v2;
}
render_many_sprites = v1 - 1;
if ( *((_DWORD *)a1 + 17) )
memoryfree(*((_DWORD *)a1 + 17));
if ( *((DWORD *)a1 + 17) )
memoryfree(*((DWORD *)a1 + 17));
memoryfree((int)a1);
return 1;
}
@@ -209,7 +209,7 @@ return 1;
// 10250B4: using guessed type int render_many_sprites;
//----- (010132E8) --------------------------------------------------------
int __stdcall render_remove_ball(struct render_sprite_type_struct *a1)
int render_remove_ball(struct render_sprite_type_struct *a1)
{
int v1; // eax
int v2; // ecx
@@ -237,7 +237,7 @@ return 1;
// 1025070: using guessed type int render_many_balls;
//----- (010133C7) --------------------------------------------------------
void __stdcall render_update()
void render_update()
{
int i; // eax
int *v1; // esi
@@ -293,7 +293,7 @@ v27 = v15;
v26 = v16;
zdrv_fill((int)&vscreen, (int)&zscreen, v16, v18, v17, v15, 0xFFFF);
if ( render_background_bitmap )
gdrv_copy_bitmap(&vscreen, v26, v18, v17, v27, (_DWORD *)render_background_bitmap, v17, v27);
gdrv_copy_bitmap(&vscreen, v26, v18, v17, v27, (DWORD *)render_background_bitmap, v17, v27);
else
gdrv_fill_bitmap((int)&vscreen, &vscreen, v26, v18, v17, v27, 0);
goto LABEL_8;
@@ -322,7 +322,7 @@ if ( i > 0 )
do
{
v5 = *v3;
if ( *((_DWORD *)*v3 + 15) > 0 && (!*((_BYTE *)v5 + 25) || *((_BYTE *)v5 + 25) == 1) )
if ( *((DWORD *)*v3 + 15) > 0 && (!*((_BYTE *)v5 + 25) || *((_BYTE *)v5 + 25) == 1) )
render_repaint(*v3);
++v4;
++v3;
@@ -340,7 +340,7 @@ for ( j = render_dirty_list; v28 < render_many_dirty; ++j )
{
v6 = *j;
v7 = (int *)((char *)*j + 52);
v8 = *((_DWORD *)*j + 15);
v8 = *((DWORD *)*j + 15);
v25 = *j;
if ( v8 > 0 )
gdrv_blit_sequence((int)&vscreen, *v7, v7[1], *v7 + v27, v7[1] + v26, v8, v7[3]);
@@ -365,7 +365,7 @@ for ( j = render_ball_list; v28 < render_many_balls; ++j )
v13 = (int *)((char *)*j + 28);
v14 = (int *)((char *)*j + 52);
if ( overlapping_box((struct rectangle_type *)v14, (struct rectangle_type *)v13, (struct rectangle_type *)&xSrc)
&& *((_DWORD *)*j + 15) > 0 )
&& *((DWORD *)*j + 15) > 0 )
{
if ( v23 > 0 )
gdrv_blit_sequence((int)&vscreen, xSrc, v22, xSrc + v27, v22 + v26, v23, v24);
@@ -395,7 +395,7 @@ render_unpaint_balls();
// 10253B0: using guessed type int render_offset_y;
//----- (01013670) --------------------------------------------------------
void __stdcall render_uninit()
void render_uninit()
{
int i; // esi
int j; // esi
@@ -421,7 +421,7 @@ render_many_balls = 0;
// 10250C0: using guessed type int render_many_dirty;
//----- (01013705) --------------------------------------------------------
char *__stdcall render_init(_DWORD *a1, float a2, float a3, int a4, int a5)
char *render_init(DWORD *a1, float a2, float a3, int a4, int a5)
{
int v5; // edi
char *result; // eax
@@ -460,7 +460,7 @@ result = (char *)gdrv_fill_bitmap((int)&vscreen, &vscreen, dword_1025094, dword_
return result;
}
// 1024F04: using guessed type int memory_critical_allocation;
// 102505A: using guessed type __int16 word_102505A;
// 102505A: using guessed type int word_102505A;
// 1025068: using guessed type struct render_sprite_type_struct **render_dirty_list;
// 102506C: using guessed type struct render_sprite_type_struct **render_ball_list;
// 1025078: using guessed type int dword_1025078;
@@ -475,7 +475,7 @@ return result;
// 10253AC: using guessed type int render_offset_x;
//----- (0101382A) --------------------------------------------------------
int __stdcall render_sprite_modified(int a1)
int render_sprite_modified(int a1)
{
int result; // eax
@@ -491,7 +491,7 @@ return result;
// 10250C0: using guessed type int render_many_dirty;
//----- (0101385C) --------------------------------------------------------
int __stdcall render_create_sprite(int a1, int a2, int a3, int a4, int a5, _DWORD *a6)
int render_create_sprite(int a1, int a2, int a3, int a4, int a5, DWORD *a6)
{
int v6; // ebx
int result; // eax
@@ -500,50 +500,50 @@ v6 = memoryallocate(0x5Cu);
result = 0;
if ( v6 )
{
*(_DWORD *)(v6 + 4) = a5;
*(_DWORD *)(v6 + 16) = a2;
*(_DWORD *)v6 = a4;
*(DWORD *)(v6 + 4) = a5;
*(DWORD *)(v6 + 16) = a2;
*(DWORD *)v6 = a4;
*(_BYTE *)(v6 + 25) = a1;
*(_BYTE *)(v6 + 24) = 0;
*(_DWORD *)(v6 + 68) = 0;
*(_DWORD *)(v6 + 72) = 0;
*(DWORD *)(v6 + 68) = 0;
*(DWORD *)(v6 + 72) = 0;
if ( a6 )
{
*(_DWORD *)(v6 + 76) = *a6;
*(_DWORD *)(v6 + 80) = a6[1];
*(_DWORD *)(v6 + 84) = a6[2];
*(_DWORD *)(v6 + 88) = a6[3];
*(DWORD *)(v6 + 76) = *a6;
*(DWORD *)(v6 + 80) = a6[1];
*(DWORD *)(v6 + 84) = a6[2];
*(DWORD *)(v6 + 88) = a6[3];
}
else
{
*(_DWORD *)(v6 + 84) = -1;
*(_DWORD *)(v6 + 88) = -1;
*(_DWORD *)(v6 + 76) = 0;
*(_DWORD *)(v6 + 80) = 0;
*(DWORD *)(v6 + 84) = -1;
*(DWORD *)(v6 + 88) = -1;
*(DWORD *)(v6 + 76) = 0;
*(DWORD *)(v6 + 80) = 0;
}
if ( a2 )
{
*(_DWORD *)(v6 + 8) = *(_DWORD *)(a2 + 12);
*(_DWORD *)(v6 + 12) = *(_DWORD *)(a2 + 16);
*(DWORD *)(v6 + 8) = *(DWORD *)(a2 + 12);
*(DWORD *)(v6 + 12) = *(DWORD *)(a2 + 16);
}
else
{
*(_DWORD *)(v6 + 8) = 0;
*(_DWORD *)(v6 + 12) = 0;
*(DWORD *)(v6 + 8) = 0;
*(DWORD *)(v6 + 12) = 0;
}
*(_DWORD *)(v6 + 20) = a3;
*(_DWORD *)(v6 + 48) = 0;
*(_DWORD *)(v6 + 44) = 0;
*(DWORD *)(v6 + 20) = a3;
*(DWORD *)(v6 + 48) = 0;
*(DWORD *)(v6 + 44) = 0;
if ( !a3 && a1 != 2 )
{
*(_DWORD *)(v6 + 20) = render_background_zmap;
*(_DWORD *)(v6 + 44) = a4 - render_zmap_offset;
*(_DWORD *)(v6 + 48) = a5 - dword_10253C0;
*(DWORD *)(v6 + 20) = render_background_zmap;
*(DWORD *)(v6 + 44) = a4 - render_zmap_offset;
*(DWORD *)(v6 + 48) = a5 - dword_10253C0;
}
*(_DWORD *)(v6 + 28) = *(_DWORD *)v6;
*(_DWORD *)(v6 + 32) = *(_DWORD *)(v6 + 4);
*(_DWORD *)(v6 + 36) = *(_DWORD *)(v6 + 8);
*(_DWORD *)(v6 + 40) = *(_DWORD *)(v6 + 12);
*(DWORD *)(v6 + 28) = *(DWORD *)v6;
*(DWORD *)(v6 + 32) = *(DWORD *)(v6 + 4);
*(DWORD *)(v6 + 36) = *(DWORD *)(v6 + 8);
*(DWORD *)(v6 + 40) = *(DWORD *)(v6 + 12);
if ( a1 == 2 )
{
render_ball_list[render_many_balls++] = (struct render_sprite_type_struct *)v6;
@@ -565,7 +565,7 @@ return result;
// 10253C0: using guessed type int dword_10253C0;
//----- (0101394E) --------------------------------------------------------
int __stdcall render_set_background_zmap(struct zmap_header_type *a1, int a2, int a3)
int render_set_background_zmap(struct zmap_header_type *a1, int a2, int a3)
{
int result; // eax
@@ -579,7 +579,7 @@ return result;
// 10253C0: using guessed type int dword_10253C0;
//----- (01013974) --------------------------------------------------------
int __stdcall render_sprite_set(_DWORD *a1, int a2, int a3, int a4, int a5)
int render_sprite_set(DWORD *a1, int a2, int a3, int a4, int a5)
{
int result; // eax
@@ -591,8 +591,8 @@ a1[1] = a5;
a1[4] = a2;
if ( a2 )
{
a1[2] = *(_DWORD *)(a2 + 12);
a1[3] = *(_DWORD *)(a2 + 16);
a1[2] = *(DWORD *)(a2 + 12);
a1[3] = *(DWORD *)(a2 + 16);
}
a1[5] = a3;
result = render_sprite_modified((int)a1);
@@ -601,46 +601,46 @@ return result;
}
//----- (010139B6) --------------------------------------------------------
void __stdcall render_sprite_set_bitmap(_DWORD *a1, int a2)
void render_sprite_set_bitmap(DWORD *a1, int a2)
{
if ( a1 && a1[4] != a2 )
{
a1[4] = a2;
if ( a2 )
{
a1[2] = *(_DWORD *)(a2 + 12);
a1[3] = *(_DWORD *)(a2 + 16);
a1[2] = *(DWORD *)(a2 + 12);
a1[3] = *(DWORD *)(a2 + 16);
}
render_sprite_modified((int)a1);
}
}
//----- (010139EC) --------------------------------------------------------
void __stdcall render_ball_set(int a1, int a2, float a3, int a4, int a5)
void render_ball_set(int a1, int a2, float a3, int a4, int a5)
{
double v5; // st7
if ( a1 )
{
*(_DWORD *)(a1 + 16) = a2;
*(DWORD *)(a1 + 16) = a2;
if ( a2 )
{
*(_DWORD *)a1 = a4;
*(_DWORD *)(a1 + 4) = a5;
*(_DWORD *)(a1 + 8) = *(_DWORD *)(a2 + 12);
*(_DWORD *)(a1 + 12) = *(_DWORD *)(a2 + 16);
*(DWORD *)a1 = a4;
*(DWORD *)(a1 + 4) = a5;
*(DWORD *)(a1 + 8) = *(DWORD *)(a2 + 12);
*(DWORD *)(a1 + 12) = *(DWORD *)(a2 + 16);
}
if ( a3 >= (double)render_zmin )
{
v5 = (a3 - render_zmin) * render_zscaler;
if ( v5 <= render_zmax )
*(_WORD *)(a1 + 26) = (signed __int64)v5;
*(WORD *)(a1 + 26) = (signed __int64)v5;
else
*(_WORD *)(a1 + 26) = -1;
*(WORD *)(a1 + 26) = -1;
}
else
{
*(_WORD *)(a1 + 26) = 0;
*(WORD *)(a1 + 26) = 0;
}
}
}
@@ -649,7 +649,7 @@ else
// 10250BC: using guessed type float render_zmin;
//----- (01013A6A) --------------------------------------------------------
void __stdcall render_paint()
void render_paint()
{
render_paint_balls();
gdrv_blat((int)&vscreen, xDest, yDest);
@@ -657,7 +657,7 @@ render_unpaint_balls();
}
//----- (01013A8F) --------------------------------------------------------
void __stdcall render_shift(int a1, int a2, int xSrc, int a4, int DestWidth, int DestHeight)
void render_shift(int a1, int a2, int xSrc, int a4, int DestWidth, int DestHeight)
{
render_offset_x += a1;
render_offset_y += a2;
graphics/splash.cpp
+32 -32
View File
@@ -5,7 +5,7 @@
#include "../pinball.h"
//----- (01006D96) --------------------------------------------------------
HPALETTE __stdcall splash_init_palette(LOGPALETTE *plpal)
HPALETTE splash_init_palette(LOGPALETTE *plpal)
{
LOGPALETTE *v1; // edi
HWND v2; // eax
@@ -75,7 +75,7 @@ HPALETTE __stdcall splash_init_palette(LOGPALETTE *plpal)
}
//----- (01006EB9) --------------------------------------------------------
HBITMAP __stdcall load_title_bitmap(HMODULE hModule, HDC hdc, LPCSTR lpName, UINT iStart, int a5, int a6)
HBITMAP load_title_bitmap(HMODULE hModule, HDC hdc, LPCSTR lpName, UINT iStart, int a5, int a6)
{
HRSRC v6; // eax
HGLOBAL v7; // eax
@@ -111,7 +111,7 @@ HBITMAP __stdcall load_title_bitmap(HMODULE hModule, HDC hdc, LPCSTR lpName, UIN
if ( !v12 && !v13 )
{
lpNamea = splash_init_palette(&plpal);
*(_DWORD *)a6 = lpNamea;
*(DWORD *)a6 = lpNamea;
if ( lpNamea )
{
hModulea = 0;
@@ -144,7 +144,7 @@ HBITMAP __stdcall load_title_bitmap(HMODULE hModule, HDC hdc, LPCSTR lpName, UIN
}
//----- (01006FCB) --------------------------------------------------------
int __stdcall splash_bitmap_setup(int a1)
int splash_bitmap_setup(int a1)
{
HWND v1; // eax
HDC v2; // eax
@@ -165,7 +165,7 @@ int __stdcall splash_bitmap_setup(int a1)
v3 = v2;
if ( v2 )
{
*(_DWORD *)(a1 + 12) = CreateCompatibleDC(v2);
*(DWORD *)(a1 + 12) = CreateCompatibleDC(v2);
v4 = CreateCompatibleBitmap(v3, 10, 10);
v5 = *(HWND *)a1;
h = v4;
@@ -180,15 +180,15 @@ int __stdcall splash_bitmap_setup(int a1)
v7 = load_title_bitmap(hInstance, *(HDC *)(a1 + 12), (LPCSTR)(a1 + 32), 0xAu, 236, a1 + 4);
else
v7 = LoadBitmapA(hInstance, (LPCSTR)(a1 + 232));
*(_DWORD *)(a1 + 8) = v7;
*(DWORD *)(a1 + 8) = v7;
if ( v7 )
{
SelectObject(*(HDC *)(a1 + 12), v7);
DeleteObject(h);
GetObjectA(*(HANDLE *)(a1 + 8), 24, &pv);
*(_DWORD *)(a1 + 16) = v10;
*(DWORD *)(a1 + 16) = v10;
result = v11;
*(_DWORD *)(a1 + 20) = v11;
*(DWORD *)(a1 + 20) = v11;
return result;
}
}
@@ -198,43 +198,43 @@ int __stdcall splash_bitmap_setup(int a1)
GetLastError();
}
}
if ( *(_DWORD *)(a1 + 4) )
if ( *(DWORD *)(a1 + 4) )
DeleteObject(*(HGDIOBJ *)(a1 + 4));
if ( *(_DWORD *)a1 )
if ( *(DWORD *)a1 )
DestroyWindow(*(HWND *)a1);
if ( h )
DeleteObject(h);
result = *(_DWORD *)(a1 + 12);
result = *(DWORD *)(a1 + 12);
if ( result )
result = DeleteDC(*(HDC *)(a1 + 12));
*(_DWORD *)(a1 + 8) = 0;
*(DWORD *)(a1 + 8) = 0;
return result;
}
//----- (01007103) --------------------------------------------------------
void __stdcall splash_paint(int a1, HDC hdc)
void splash_paint(int a1, HDC hdc)
{
HWND v2; // eax
HPALETTE v3; // ST1C_4
struct tagRECT Rect; // [esp+4h] [ebp-10h]
if ( *(_DWORD *)(a1 + 8) )
if ( *(DWORD *)(a1 + 8) )
{
v2 = GetDesktopWindow();
GetWindowRect(v2, &Rect);
v3 = *(HPALETTE *)(a1 + 4);
*(_DWORD *)(a1 + 24) = (Rect.right - Rect.left - *(_DWORD *)(a1 + 16)) / 2;
*(_DWORD *)(a1 + 28) = (Rect.bottom - Rect.top - *(_DWORD *)(a1 + 20)) / 2;
*(DWORD *)(a1 + 24) = (Rect.right - Rect.left - *(DWORD *)(a1 + 16)) / 2;
*(DWORD *)(a1 + 28) = (Rect.bottom - Rect.top - *(DWORD *)(a1 + 20)) / 2;
SelectPalette(hdc, v3, 0);
RealizePalette(hdc);
SelectPalette(*(HDC *)(a1 + 12), *(HPALETTE *)(a1 + 4), 0);
RealizePalette(*(HDC *)(a1 + 12));
BitBlt(
hdc,
*(_DWORD *)(a1 + 24),
*(_DWORD *)(a1 + 28),
*(_DWORD *)(a1 + 16),
*(_DWORD *)(a1 + 20),
*(DWORD *)(a1 + 24),
*(DWORD *)(a1 + 28),
*(DWORD *)(a1 + 16),
*(DWORD *)(a1 + 20),
*(HDC *)(a1 + 12),
0,
0,
@@ -243,23 +243,23 @@ void __stdcall splash_paint(int a1, HDC hdc)
}
//----- (010071A5) --------------------------------------------------------
void __stdcall splash_hide(int a1)
void splash_hide(int a1)
{
HDC v1; // edi
if ( a1 )
{
if ( *(_DWORD *)a1 )
if ( *(DWORD *)a1 )
{
v1 = _GetDC(*(HWND *)a1);
BitBlt(v1, 0, 0, *(_DWORD *)(a1 + 24), *(_DWORD *)(a1 + 28), v1, 0, 0, 0x42u);
BitBlt(v1, 0, 0, *(DWORD *)(a1 + 24), *(DWORD *)(a1 + 28), v1, 0, 0, 0x42u);
ReleaseDC(*(HWND *)a1, v1);
}
}
}
//----- (010071ED) --------------------------------------------------------
HINSTANCE __stdcall splash_destroy(int a1)
HINSTANCE splash_destroy(int a1)
{
void *v1; // eax
HDC v2; // eax
@@ -267,18 +267,18 @@ HINSTANCE __stdcall splash_destroy(int a1)
if ( a1 )
{
if ( *(_DWORD *)a1 )
if ( *(DWORD *)a1 )
{
DestroyWindow(*(HWND *)a1);
v1 = *(void **)(a1 + 4);
*(_DWORD *)a1 = 0;
*(DWORD *)a1 = 0;
if ( v1 )
DeleteObject(v1);
v2 = *(HDC *)(a1 + 12);
*(_DWORD *)(a1 + 4) = 0;
*(DWORD *)(a1 + 4) = 0;
if ( v2 )
DeleteDC(v2);
if ( *(_DWORD *)(a1 + 8) )
if ( *(DWORD *)(a1 + 8) )
DeleteObject(*(HGDIOBJ *)(a1 + 8));
}
memoryfree(a1);
@@ -293,7 +293,7 @@ HINSTANCE __stdcall splash_destroy(int a1)
}
//----- (01007264) --------------------------------------------------------
LRESULT __stdcall splash_message_handler(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
LRESULT splash_message_handler(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
HDC v5; // eax
HDC v6; // esi
@@ -325,7 +325,7 @@ LRESULT __stdcall splash_message_handler(HWND hWnd, UINT Msg, WPARAM wParam, LPA
}
//----- (01007308) --------------------------------------------------------
int __stdcall splash_screen(int a1, LPCSTR lpString2, LPCSTR a3)
int splash_screen(int a1, LPCSTR lpString2, LPCSTR a3)
{
int v3; // esi
HINSTANCE v4; // ST28_4
@@ -355,9 +355,9 @@ int __stdcall splash_screen(int a1, LPCSTR lpString2, LPCSTR a3)
RegisterClassA(&WndClass);
}
v4 = hInstance;
*(_DWORD *)(v3 + 8) = 0;
*(DWORD *)(v3 + 8) = 0;
v5 = CreateWindowExA(0, "3DPB_SPLASH_CLASS", WindowName, 0x80000000, -10, -10, 1, 1, 0, 0, v4, 0);
*(_DWORD *)v3 = v5;
*(DWORD *)v3 = v5;
if ( !v5 )
{
memoryfree(v3);
graphics/timer.cpp
+34 -34
View File
@@ -5,11 +5,11 @@
#include "../pinball.h"
//----- (0100742F) --------------------------------------------------------
signed int __stdcall timer_init(int a1)
signed int timer_init(int a1)
{
int v1; // eax
int v3; // edx
_DWORD *v4; // ecx
DWORD *v4; // ecx
v1 = memoryallocate(20 * a1);
dword_1024F80 = v1;
@@ -21,7 +21,7 @@ signed int __stdcall timer_init(int a1)
dword_10235F4 = 1;
if ( a1 - 1 > 0 )
{
v4 = (_DWORD *)(v1 + 12);
v4 = (DWORD *)(v1 + 12);
do
{
*v4 = v4 + 2;
@@ -30,7 +30,7 @@ signed int __stdcall timer_init(int a1)
}
while ( v3 );
}
*(_DWORD *)(20 * a1 + v1 - 8) = 0;
*(DWORD *)(20 * a1 + v1 - 8) = 0;
dword_1024F70 = 0;
dword_1024F7C = v1;
return 0;
@@ -43,7 +43,7 @@ signed int __stdcall timer_init(int a1)
// 1024F80: using guessed type int dword_1024F80;
//----- (0100749B) --------------------------------------------------------
void __stdcall timer_uninit()
void timer_uninit()
{
if ( dword_1024F80 )
memoryfree(dword_1024F80);
@@ -52,15 +52,15 @@ void __stdcall timer_uninit()
// 1024F80: using guessed type int dword_1024F80;
//----- (010074B7) --------------------------------------------------------
int __stdcall timer_set(float a1, int a2, int a3)
int timer_set(float a1, int a2, int a3)
{
signed __int64 v3; // rax
int v4; // esi
int v5; // ebx
_DWORD *v7; // ecx
_DWORD *v8; // eax
DWORD *v7; // ecx
DWORD *v8; // eax
int v9; // edx
_DWORD *v10; // edi
DWORD *v10; // edi
int v11; // eax
int v12; // [esp+0h] [ebp-8h]
int v13; // [esp+4h] [ebp-4h]
@@ -73,28 +73,28 @@ int __stdcall timer_set(float a1, int a2, int a3)
if ( dword_1024F78 >= dword_1024F74 )
return 0;
v14 = 0;
v7 = (_DWORD *)dword_1024F7C;
v8 = (_DWORD *)(dword_1024F7C + 12);
v9 = *(_DWORD *)(dword_1024F7C + 12);
*(_DWORD *)(dword_1024F7C + 12) = 0;
v7 = (DWORD *)dword_1024F7C;
v8 = (DWORD *)(dword_1024F7C + 12);
v9 = *(DWORD *)(dword_1024F7C + 12);
*(DWORD *)(dword_1024F7C + 12) = 0;
dword_1024F7C = v9;
v13 = dword_1024F70;
v10 = (_DWORD *)dword_1024F70;
v10 = (DWORD *)dword_1024F70;
if ( v4 > 0 )
{
while ( v5 >= *v10 )
{
++v14;
v13 = (int)v10;
v10 = (_DWORD *)v10[3];
v10 = (DWORD *)v10[3];
if ( v14 >= v4 )
break;
v5 = v12;
}
if ( v10 != (_DWORD *)v13 )
if ( v10 != (DWORD *)v13 )
{
*v8 = *(_DWORD *)(v13 + 12);
*(_DWORD *)(v13 + 12) = v7;
*v8 = *(DWORD *)(v13 + 12);
*(DWORD *)(v13 + 12) = v7;
v5 = v12;
goto LABEL_12;
}
@@ -122,21 +122,21 @@ int __stdcall timer_set(float a1, int a2, int a3)
// 1024F84: using guessed type int time_ticks;
//----- (0100758D) --------------------------------------------------------
signed int __stdcall timer_check()
signed int timer_check()
{
_DWORD *v0; // eax
DWORD *v0; // eax
signed int v1; // ebx
_DWORD *v2; // ecx
DWORD *v2; // ecx
int v3; // edx
bool v4; // zf
_DWORD *v5; // ecx
DWORD *v5; // ecx
int v6; // edx
char v8; // [esp+4h] [ebp-14h]
int v9; // [esp+8h] [ebp-10h]
void (__stdcall *v10)(int, int); // [esp+Ch] [ebp-Ch]
void (*v10)(int, int); // [esp+Ch] [ebp-Ch]
int v11; // [esp+14h] [ebp-4h]
v0 = (_DWORD *)dword_1024F70;
v0 = (DWORD *)dword_1024F70;
v1 = 0;
if ( dword_1024F70 )
{
@@ -146,7 +146,7 @@ signed int __stdcall timer_check()
qmemcpy(&v8, v0, 0x14u);
v2 = v0 + 3;
v3 = (int)v0;
v0 = (_DWORD *)v0[3];
v0 = (DWORD *)v0[3];
++v1;
v4 = v10 == 0;
dword_1024F70 = (int)v0;
@@ -155,7 +155,7 @@ signed int __stdcall timer_check()
if ( !v4 )
{
v10(v11, v9);
v0 = (_DWORD *)dword_1024F70;
v0 = (DWORD *)dword_1024F70;
}
if ( v1 > 1 )
break;
@@ -169,14 +169,14 @@ signed int __stdcall timer_check()
v4 = v10 == 0;
v5 = v0 + 3;
v6 = (int)v0;
v0 = (_DWORD *)v0[3];
v0 = (DWORD *)v0[3];
dword_1024F70 = (int)v0;
*v5 = dword_1024F7C;
dword_1024F7C = v6;
if ( !v4 )
{
v10(v11, v9);
v0 = (_DWORD *)dword_1024F70;
v0 = (DWORD *)dword_1024F70;
}
++v1;
}
@@ -189,7 +189,7 @@ signed int __stdcall timer_check()
// 1024F84: using guessed type int time_ticks;
//----- (01007659) --------------------------------------------------------
int __stdcall timer_kill(int a1)
int timer_kill(int a1)
{
int v1; // ecx
int v2; // esi
@@ -202,20 +202,20 @@ int __stdcall timer_kill(int a1)
if ( dword_1024F78 <= 0 )
return 0;
result = a1;
while ( a1 != *(_DWORD *)(v1 + 16) )
while ( a1 != *(DWORD *)(v1 + 16) )
{
++v2;
v3 = v1;
v1 = *(_DWORD *)(v1 + 12);
v1 = *(DWORD *)(v1 + 12);
if ( v2 >= dword_1024F78 )
return 0;
}
if ( v3 )
*(_DWORD *)(v3 + 12) = *(_DWORD *)(v1 + 12);
*(DWORD *)(v3 + 12) = *(DWORD *)(v1 + 12);
else
dword_1024F70 = *(_DWORD *)(v1 + 12);
dword_1024F70 = *(DWORD *)(v1 + 12);
--dword_1024F78;
*(_DWORD *)(v1 + 12) = dword_1024F7C;
*(DWORD *)(v1 + 12) = dword_1024F7C;
dword_1024F7C = v1;
return result;
}