678 lines
16 KiB
C++
678 lines
16 KiB
C++
#include "../pinball.h"
|
|
|
|
//----- (0101304D) --------------------------------------------------------
|
|
void __stdcall render_repaint(struct render_sprite_type_struct *a1)
|
|
{
|
|
int *v1; // edi
|
|
bool v2; // zf
|
|
bool v3; // sf
|
|
int v4; // esi
|
|
int v5; // [esp+8h] [ebp-10h]
|
|
int v6; // [esp+Ch] [ebp-Ch]
|
|
int v7; // [esp+10h] [ebp-8h]
|
|
int v8; // [esp+14h] [ebp-4h]
|
|
struct render_sprite_type_struct *v9; // [esp+20h] [ebp+8h]
|
|
|
|
v1 = (int *)a1;
|
|
if ( *((_DWORD *)a1 + 17) )
|
|
{
|
|
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) )
|
|
{
|
|
if ( rectangle_clip((int *)v4, v1 + 13, &v5) )
|
|
zdrv_paint(
|
|
v7,
|
|
v8,
|
|
&vscreen,
|
|
v5,
|
|
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));
|
|
}
|
|
v9 = (struct render_sprite_type_struct *)((char *)v9 + 1);
|
|
}
|
|
while ( (signed int)v9 < v1[18] );
|
|
}
|
|
}
|
|
}
|
|
|
|
//----- (010130F3) --------------------------------------------------------
|
|
void __stdcall render_paint_balls()
|
|
{
|
|
int v0; // ecx
|
|
int v1; // edi
|
|
int i; // esi
|
|
struct render_sprite_type_struct *v3; // edx
|
|
struct render_sprite_type_struct **v4; // eax
|
|
struct render_sprite_type_struct *v5; // ecx
|
|
struct render_sprite_type_struct *v6; // edi
|
|
int *v7; // esi
|
|
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]
|
|
|
|
v0 = render_many_balls;
|
|
if ( render_many_balls > 1 )
|
|
{
|
|
v1 = 0;
|
|
if ( render_many_balls > 0 )
|
|
{
|
|
do
|
|
{
|
|
for ( i = v1; i < v0 / 2; ++i )
|
|
{
|
|
v3 = render_ball_list[i];
|
|
v4 = &render_ball_list[v1];
|
|
if ( *((_WORD *)*v4 + 13) > *((_WORD *)v3 + 13) )
|
|
{
|
|
v5 = *v4;
|
|
*v4 = v3;
|
|
render_ball_list[i] = v5;
|
|
v0 = render_many_balls;
|
|
}
|
|
}
|
|
++v1;
|
|
}
|
|
while ( v1 < v0 );
|
|
}
|
|
}
|
|
v10 = 0;
|
|
v11 = render_ball_list;
|
|
if ( v0 > 0 )
|
|
{
|
|
v12 = &ball_bitmap;
|
|
do
|
|
{
|
|
v6 = *v11;
|
|
v7 = (int *)((char *)*v11 + 52);
|
|
if ( *((_DWORD *)*v11 + 4) && rectangle_clip((int *)v6, (int *)&vscreen_rect, (_DWORD *)*v11 + 13) )
|
|
{
|
|
v8 = *v7;
|
|
v9 = v7[1];
|
|
gdrv_copy_bitmap(v12, v7[2], v7[3], 0, 0, &vscreen, *v7, v9);
|
|
zdrv_paint_flat(
|
|
v7[2],
|
|
v7[3],
|
|
&vscreen,
|
|
v8,
|
|
v9,
|
|
(int)&zscreen,
|
|
v8,
|
|
v9,
|
|
*((_DWORD **)v6 + 4),
|
|
v8 - *(_DWORD *)v6,
|
|
v9 - *((_DWORD *)v6 + 1),
|
|
*((_WORD *)v6 + 13));
|
|
}
|
|
else
|
|
{
|
|
v7[2] = -1;
|
|
}
|
|
++v10;
|
|
v12 = (_DWORD *)((char *)v12 + 37);
|
|
++v11;
|
|
}
|
|
while ( v10 < render_many_balls );
|
|
}
|
|
}
|
|
// 102506C: using guessed type struct render_sprite_type_struct **render_ball_list;
|
|
// 1025070: using guessed type int render_many_balls;
|
|
|
|
//----- (0101320D) --------------------------------------------------------
|
|
void __stdcall render_unpaint_balls()
|
|
{
|
|
_DWORD *v0; // ebx
|
|
struct render_sprite_type_struct *v1; // edi
|
|
_DWORD *v2; // esi
|
|
int v3; // eax
|
|
_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]
|
|
|
|
v8 = &render_ball_list[render_many_balls - 1];
|
|
if ( render_many_balls - 1 >= 0 )
|
|
{
|
|
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);
|
|
if ( v3 > 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 = *v2;
|
|
v5 = v2 + 1;
|
|
++v4;
|
|
*v4 = *v5;
|
|
++v5;
|
|
++v4;
|
|
*v4 = *v5;
|
|
v0 = (_DWORD *)((char *)v0 - 37);
|
|
v6 = v7-- == 1;
|
|
v4[1] = v5[1];
|
|
}
|
|
while ( !v6 );
|
|
}
|
|
}
|
|
// 102506C: using guessed type struct render_sprite_type_struct **render_ball_list;
|
|
// 1025070: using guessed type int render_many_balls;
|
|
|
|
//----- (01013283) --------------------------------------------------------
|
|
int __stdcall render_remove_sprite(struct render_sprite_type_struct *a1)
|
|
{
|
|
int v1; // eax
|
|
int v2; // ecx
|
|
|
|
v1 = render_many_sprites;
|
|
v2 = 0;
|
|
if ( render_many_sprites <= 0 )
|
|
return 0;
|
|
while ( render_sprite_list[v2] != a1 )
|
|
{
|
|
if ( ++v2 >= render_many_sprites )
|
|
return 0;
|
|
}
|
|
while ( v2 < v1 )
|
|
{
|
|
render_sprite_list[v2] = render_sprite_list[v2 + 1];
|
|
v1 = render_many_sprites;
|
|
++v2;
|
|
}
|
|
render_many_sprites = v1 - 1;
|
|
if ( *((_DWORD *)a1 + 17) )
|
|
memoryfree(*((_DWORD *)a1 + 17));
|
|
memoryfree((int)a1);
|
|
return 1;
|
|
}
|
|
// 1025084: using guessed type struct render_sprite_type_struct **render_sprite_list;
|
|
// 10250B4: using guessed type int render_many_sprites;
|
|
|
|
//----- (010132E8) --------------------------------------------------------
|
|
int __stdcall render_remove_ball(struct render_sprite_type_struct *a1)
|
|
{
|
|
int v1; // eax
|
|
int v2; // ecx
|
|
|
|
v1 = render_many_balls;
|
|
v2 = 0;
|
|
if ( render_many_balls <= 0 )
|
|
return 0;
|
|
while ( render_ball_list[v2] != a1 )
|
|
{
|
|
if ( ++v2 >= render_many_balls )
|
|
return 0;
|
|
}
|
|
while ( v2 < v1 )
|
|
{
|
|
render_ball_list[v2] = render_ball_list[v2 + 1];
|
|
v1 = render_many_balls;
|
|
++v2;
|
|
}
|
|
render_many_balls = v1 - 1;
|
|
memoryfree((int)a1);
|
|
return 1;
|
|
}
|
|
// 102506C: using guessed type struct render_sprite_type_struct **render_ball_list;
|
|
// 1025070: using guessed type int render_many_balls;
|
|
|
|
//----- (010133C7) --------------------------------------------------------
|
|
void __stdcall render_update()
|
|
{
|
|
int i; // eax
|
|
int *v1; // esi
|
|
int *v2; // edi
|
|
struct render_sprite_type_struct **v3; // esi
|
|
int v4; // edi
|
|
struct render_sprite_type_struct *v5; // eax
|
|
struct render_sprite_type_struct *v6; // edi
|
|
int *v7; // esi
|
|
int v8; // edx
|
|
struct render_sprite_type_struct *v9; // eax
|
|
int *v10; // edi
|
|
bool v11; // zf
|
|
int *v12; // esi
|
|
int *v13; // edi
|
|
int *v14; // esi
|
|
int v15; // eax
|
|
unsigned int v16; // ecx
|
|
int v17; // edi
|
|
int v18; // esi
|
|
int v19; // edx
|
|
int v20; // edx
|
|
int xSrc; // [esp+Ch] [ebp-24h]
|
|
int v22; // [esp+10h] [ebp-20h]
|
|
int v23; // [esp+14h] [ebp-1Ch]
|
|
int v24; // [esp+18h] [ebp-18h]
|
|
struct render_sprite_type_struct *v25; // [esp+1Ch] [ebp-14h]
|
|
int v26; // [esp+20h] [ebp-10h]
|
|
int v27; // [esp+24h] [ebp-Ch]
|
|
int v28; // [esp+28h] [ebp-8h]
|
|
struct render_sprite_type_struct **j; // [esp+2Ch] [ebp-4h]
|
|
|
|
v28 = 0;
|
|
j = render_dirty_list;
|
|
for ( i = render_many_dirty; v28 < render_many_dirty; ++j )
|
|
{
|
|
v1 = (int *)*j;
|
|
if ( *((_BYTE *)*j + 25) )
|
|
{
|
|
if ( *((_BYTE *)*j + 25) == 1 )
|
|
{
|
|
if ( v1[9] > 0 )
|
|
enclosing_box(v1 + 7, v1, v1 + 13);
|
|
v2 = v1 + 13;
|
|
if ( rectangle_clip(v1 + 13, (int *)&vscreen_rect, v1 + 13) )
|
|
{
|
|
LABEL_29:
|
|
v15 = v1[14];
|
|
v16 = v1[15];
|
|
v17 = *v2;
|
|
v18 = v1[16];
|
|
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);
|
|
else
|
|
gdrv_fill_bitmap((int)&vscreen, &vscreen, v26, v18, v17, v27, 0);
|
|
goto LABEL_8;
|
|
}
|
|
LABEL_7:
|
|
v1[15] = -1;
|
|
goto LABEL_8;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
v2 = v1 + 13;
|
|
if ( !rectangle_clip(v1, (int *)&vscreen_rect, v1 + 13) )
|
|
goto LABEL_7;
|
|
if ( !v1[4] )
|
|
goto LABEL_29;
|
|
}
|
|
LABEL_8:
|
|
++v28;
|
|
i = render_many_dirty;
|
|
}
|
|
v3 = render_dirty_list;
|
|
v4 = 0;
|
|
if ( i > 0 )
|
|
{
|
|
do
|
|
{
|
|
v5 = *v3;
|
|
if ( *((_DWORD *)*v3 + 15) > 0 && (!*((_BYTE *)v5 + 25) || *((_BYTE *)v5 + 25) == 1) )
|
|
render_repaint(*v3);
|
|
++v4;
|
|
++v3;
|
|
}
|
|
while ( v4 < render_many_dirty );
|
|
}
|
|
render_paint_balls();
|
|
if ( render_blit )
|
|
{
|
|
gdrv_start_blit_sequence();
|
|
v27 = xDest + render_offset_x;
|
|
v26 = yDest + render_offset_y;
|
|
v28 = 0;
|
|
for ( j = render_dirty_list; v28 < render_many_dirty; ++j )
|
|
{
|
|
v6 = *j;
|
|
v7 = (int *)((char *)*j + 52);
|
|
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]);
|
|
v9 = v25;
|
|
v10 = (int *)((char *)v6 + 28);
|
|
v11 = *((_BYTE *)v25 + 24) == 0;
|
|
*v10 = *v7;
|
|
v12 = v7 + 1;
|
|
++v10;
|
|
*v10 = *v12;
|
|
++v12;
|
|
++v10;
|
|
*v10 = *v12;
|
|
v10[1] = v12[1];
|
|
if ( !v11 )
|
|
render_remove_sprite(v9);
|
|
++v28;
|
|
}
|
|
v28 = 0;
|
|
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 )
|
|
{
|
|
if ( v23 > 0 )
|
|
gdrv_blit_sequence((int)&vscreen, xSrc, v22, xSrc + v27, v22 + v26, v23, v24);
|
|
}
|
|
else
|
|
{
|
|
v19 = v14[2];
|
|
if ( v19 > 0 )
|
|
gdrv_blit_sequence((int)&vscreen, *v14, v14[1], *v14 + v27, v14[1] + v26, v19, v14[3]);
|
|
v20 = v13[2];
|
|
if ( v20 > 0 )
|
|
gdrv_blit_sequence((int)&vscreen, *v13, v13[1], *v13 + v27, v13[1] + v26, v20, v13[3]);
|
|
}
|
|
++v28;
|
|
}
|
|
gdrv_end_blit_sequence();
|
|
}
|
|
render_many_dirty = 0;
|
|
render_unpaint_balls();
|
|
}
|
|
// 1024754: using guessed type int render_blit;
|
|
// 1025068: using guessed type struct render_sprite_type_struct **render_dirty_list;
|
|
// 102506C: using guessed type struct render_sprite_type_struct **render_ball_list;
|
|
// 1025070: using guessed type int render_many_balls;
|
|
// 10250C0: using guessed type int render_many_dirty;
|
|
// 10253AC: using guessed type int render_offset_x;
|
|
// 10253B0: using guessed type int render_offset_y;
|
|
|
|
//----- (01013670) --------------------------------------------------------
|
|
void __stdcall render_uninit()
|
|
{
|
|
int i; // esi
|
|
int j; // esi
|
|
|
|
gdrv_destroy_bitmap((int)&vscreen);
|
|
zdrv_destroy_zmap(&zscreen);
|
|
for ( i = 0; i < render_many_sprites; ++i )
|
|
render_remove_sprite(render_sprite_list[i]);
|
|
for ( j = 0; j < render_many_balls; ++j )
|
|
render_remove_ball(render_ball_list[j]);
|
|
memoryfree((int)render_ball_list);
|
|
memoryfree((int)render_dirty_list);
|
|
memoryfree((int)render_sprite_list);
|
|
render_many_sprites = 0;
|
|
render_many_dirty = 0;
|
|
render_many_balls = 0;
|
|
}
|
|
// 1025068: using guessed type struct render_sprite_type_struct **render_dirty_list;
|
|
// 102506C: using guessed type struct render_sprite_type_struct **render_ball_list;
|
|
// 1025070: using guessed type int render_many_balls;
|
|
// 1025084: using guessed type struct render_sprite_type_struct **render_sprite_list;
|
|
// 10250B4: using guessed type int render_many_sprites;
|
|
// 10250C0: using guessed type int render_many_dirty;
|
|
|
|
//----- (01013705) --------------------------------------------------------
|
|
char *__stdcall render_init(_DWORD *a1, float a2, float a3, int a4, int a5)
|
|
{
|
|
int v5; // edi
|
|
char *result; // eax
|
|
char *v7; // [esp+18h] [ebp+18h]
|
|
|
|
++memory_critical_allocation;
|
|
render_zscaler = a3;
|
|
render_zmin = a2;
|
|
render_zmax = 4294967300.0 / a3 + a2;
|
|
render_sprite_list = (struct render_sprite_type_struct **)memoryallocate(0xFA0u);
|
|
render_dirty_list = (struct render_sprite_type_struct **)memoryallocate(0xFA0u);
|
|
render_ball_list = (struct render_sprite_type_struct **)memoryallocate(0x50u);
|
|
gdrv_create_bitmap((int)&vscreen, a4, a5);
|
|
zdrv_create_zmap((int)&zscreen, a4, a5);
|
|
zdrv_fill((int)&vscreen, (int)&zscreen, zscreen, word_102505A, 0, 0, 0xFFFF);
|
|
v5 = a5;
|
|
dword_1025078 = 0;
|
|
vscreen_rect = 0;
|
|
dword_102507C = a4;
|
|
dword_1025080 = a5;
|
|
yDest = 0;
|
|
xDest = 0;
|
|
v7 = (char *)&ball_bitmap;
|
|
do
|
|
{
|
|
gdrv_create_raw_bitmap((int)v7, 64, 64, 1);
|
|
v7 += 37;
|
|
}
|
|
while ( (signed int)v7 < (signed int)&render_offset_x );
|
|
render_background_bitmap = (int)a1;
|
|
if ( a1 )
|
|
result = gdrv_copy_bitmap(&vscreen, a4, v5, 0, 0, a1, 0, 0);
|
|
else
|
|
result = (char *)gdrv_fill_bitmap((int)&vscreen, &vscreen, dword_1025094, dword_1025098, 0, 0, 0);
|
|
--memory_critical_allocation;
|
|
return result;
|
|
}
|
|
// 1024F04: using guessed type int memory_critical_allocation;
|
|
// 102505A: using guessed type __int16 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;
|
|
// 102507C: using guessed type int dword_102507C;
|
|
// 1025080: using guessed type int dword_1025080;
|
|
// 1025084: using guessed type struct render_sprite_type_struct **render_sprite_list;
|
|
// 1025094: using guessed type int dword_1025094;
|
|
// 1025098: using guessed type int dword_1025098;
|
|
// 10250B0: using guessed type float render_zscaler;
|
|
// 10250B8: using guessed type float render_zmax;
|
|
// 10250BC: using guessed type float render_zmin;
|
|
// 10253AC: using guessed type int render_offset_x;
|
|
|
|
//----- (0101382A) --------------------------------------------------------
|
|
int __stdcall render_sprite_modified(int a1)
|
|
{
|
|
int result; // eax
|
|
|
|
if ( *(_BYTE *)(a1 + 25) != 2 )
|
|
{
|
|
result = render_many_dirty;
|
|
if ( render_many_dirty < 999 )
|
|
render_dirty_list[render_many_dirty++] = (struct render_sprite_type_struct *)a1;
|
|
}
|
|
return result;
|
|
}
|
|
// 1025068: using guessed type struct render_sprite_type_struct **render_dirty_list;
|
|
// 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 v6; // ebx
|
|
int result; // eax
|
|
|
|
v6 = memoryallocate(0x5Cu);
|
|
result = 0;
|
|
if ( v6 )
|
|
{
|
|
*(_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;
|
|
if ( a6 )
|
|
{
|
|
*(_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;
|
|
}
|
|
if ( a2 )
|
|
{
|
|
*(_DWORD *)(v6 + 8) = *(_DWORD *)(a2 + 12);
|
|
*(_DWORD *)(v6 + 12) = *(_DWORD *)(a2 + 16);
|
|
}
|
|
else
|
|
{
|
|
*(_DWORD *)(v6 + 8) = 0;
|
|
*(_DWORD *)(v6 + 12) = 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 + 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;
|
|
}
|
|
else
|
|
{
|
|
render_sprite_list[render_many_sprites++] = (struct render_sprite_type_struct *)v6;
|
|
render_sprite_modified(v6);
|
|
}
|
|
result = v6;
|
|
}
|
|
return result;
|
|
}
|
|
// 102506C: using guessed type struct render_sprite_type_struct **render_ball_list;
|
|
// 1025070: using guessed type int render_many_balls;
|
|
// 1025084: using guessed type struct render_sprite_type_struct **render_sprite_list;
|
|
// 10250B4: using guessed type int render_many_sprites;
|
|
// 10253B8: using guessed type struct zmap_header_type *render_background_zmap;
|
|
// 10253C0: using guessed type int dword_10253C0;
|
|
|
|
//----- (0101394E) --------------------------------------------------------
|
|
int __stdcall render_set_background_zmap(struct zmap_header_type *a1, int a2, int a3)
|
|
{
|
|
int result; // eax
|
|
|
|
render_background_zmap = a1;
|
|
render_zmap_offset = a2;
|
|
result = a3;
|
|
dword_10253C0 = a3;
|
|
return result;
|
|
}
|
|
// 10253B8: using guessed type struct zmap_header_type *render_background_zmap;
|
|
// 10253C0: using guessed type int dword_10253C0;
|
|
|
|
//----- (01013974) --------------------------------------------------------
|
|
int __stdcall render_sprite_set(_DWORD *a1, int a2, int a3, int a4, int a5)
|
|
{
|
|
int result; // eax
|
|
|
|
result = (int)a1;
|
|
if ( a1 )
|
|
{
|
|
*a1 = a4;
|
|
a1[1] = a5;
|
|
a1[4] = a2;
|
|
if ( a2 )
|
|
{
|
|
a1[2] = *(_DWORD *)(a2 + 12);
|
|
a1[3] = *(_DWORD *)(a2 + 16);
|
|
}
|
|
a1[5] = a3;
|
|
result = render_sprite_modified((int)a1);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (010139B6) --------------------------------------------------------
|
|
void __stdcall 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);
|
|
}
|
|
render_sprite_modified((int)a1);
|
|
}
|
|
}
|
|
|
|
//----- (010139EC) --------------------------------------------------------
|
|
void __stdcall render_ball_set(int a1, int a2, float a3, int a4, int a5)
|
|
{
|
|
double v5; // st7
|
|
|
|
if ( a1 )
|
|
{
|
|
*(_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);
|
|
}
|
|
if ( a3 >= (double)render_zmin )
|
|
{
|
|
v5 = (a3 - render_zmin) * render_zscaler;
|
|
if ( v5 <= render_zmax )
|
|
*(_WORD *)(a1 + 26) = (signed __int64)v5;
|
|
else
|
|
*(_WORD *)(a1 + 26) = -1;
|
|
}
|
|
else
|
|
{
|
|
*(_WORD *)(a1 + 26) = 0;
|
|
}
|
|
}
|
|
}
|
|
// 10250B0: using guessed type float render_zscaler;
|
|
// 10250B8: using guessed type float render_zmax;
|
|
// 10250BC: using guessed type float render_zmin;
|
|
|
|
//----- (01013A6A) --------------------------------------------------------
|
|
void __stdcall render_paint()
|
|
{
|
|
render_paint_balls();
|
|
gdrv_blat((int)&vscreen, xDest, yDest);
|
|
render_unpaint_balls();
|
|
}
|
|
|
|
//----- (01013A8F) --------------------------------------------------------
|
|
void __stdcall render_shift(int a1, int a2, int xSrc, int a4, int DestWidth, int DestHeight)
|
|
{
|
|
render_offset_x += a1;
|
|
render_offset_y += a2;
|
|
render_paint_balls();
|
|
gdrv_blit(
|
|
(int)&vscreen,
|
|
xSrc,
|
|
a4,
|
|
xSrc + render_offset_x + xDest,
|
|
a4 + render_offset_y + yDest,
|
|
DestWidth,
|
|
DestHeight);
|
|
render_unpaint_balls();
|
|
}
|
|
// 10253AC: using guessed type int render_offset_x;
|
|
// 10253B0: using guessed type int render_offset_y;
|
|
|