ShuriZma
/
project64
mirror of https://github.com/project64/project64.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[Video] Make rdp.tiles private

This commit is contained in:
zilmar 2017-05-19 21:19:34 +10:00
parent 5d9ca779ac
commit f9c6df3e8d
14 changed files with 370 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
Source/Project64-video/3dmath.cpp
View File

@ -84,8 +84,8 @@ void calc_linear(VERTEX *v)
if (rdp.cur_cache[0]) if (rdp.cur_cache[0])
{ {
// scale >> 6 is size to map to // scale >> 6 is size to map to
v->ou = (acosf(-x) / 3.141592654f) * (rdp.tiles[rdp.cur_tile].org_s_scale >> 6); v->ou = (acosf(-x) / 3.141592654f) * (rdp.tiles(rdp.cur_tile).org_s_scale >> 6);
v->ov = (acosf(-y) / 3.141592654f) * (rdp.tiles[rdp.cur_tile].org_t_scale >> 6); v->ov = (acosf(-y) / 3.141592654f) * (rdp.tiles(rdp.cur_tile).org_t_scale >> 6);
} }
v->uv_scaled = 1; v->uv_scaled = 1;
WriteTrace(TraceRDP, TraceVerbose, "calc linear u: %f, v: %f", v->ou, v->ov); WriteTrace(TraceRDP, TraceVerbose, "calc linear u: %f, v: %f", v->ou, v->ov);
@ -98,13 +98,13 @@ void calc_sphere(VERTEX *v)
int s_scale, t_scale; int s_scale, t_scale;
if (g_settings->hacks(CSettings::hack_Chopper)) if (g_settings->hacks(CSettings::hack_Chopper))
{ {
s_scale = minval(rdp.tiles[rdp.cur_tile].org_s_scale >> 6, rdp.tiles[rdp.cur_tile].lr_s); s_scale = minval(rdp.tiles(rdp.cur_tile).org_s_scale >> 6, rdp.tiles(rdp.cur_tile).lr_s);
t_scale = minval(rdp.tiles[rdp.cur_tile].org_t_scale >> 6, rdp.tiles[rdp.cur_tile].lr_t); t_scale = minval(rdp.tiles(rdp.cur_tile).org_t_scale >> 6, rdp.tiles(rdp.cur_tile).lr_t);
} }
else else
{ {
s_scale = rdp.tiles[rdp.cur_tile].org_s_scale >> 6; s_scale = rdp.tiles(rdp.cur_tile).org_s_scale >> 6;
t_scale = rdp.tiles[rdp.cur_tile].org_t_scale >> 6; t_scale = rdp.tiles(rdp.cur_tile).org_t_scale >> 6;
} }
TransformVector(v->vec, vec, rdp.model); TransformVector(v->vec, vec, rdp.model);
// TransformVector (v->vec, vec, rdp.combined); // TransformVector (v->vec, vec, rdp.combined);
@ -215,7 +215,7 @@ void MulMatricesSSE(float m1[4][4], float m2[4][4], float r[4][4])
{ {
#if defined(__GNUC__) && !defined(NO_ASM) && !defined(NOSSE) #if defined(__GNUC__) && !defined(NO_ASM) && !defined(NOSSE)
/* [row][col]*/ /* [row][col]*/
typedef float v4sf __attribute__ ((vector_size (16))); typedef float v4sf __attribute__((vector_size(16)));
v4sf row0 = _mm_loadu_ps(m2[0]); v4sf row0 = _mm_loadu_ps(m2[0]);
v4sf row1 = _mm_loadu_ps(m2[1]); v4sf row1 = _mm_loadu_ps(m2[1]);
v4sf row2 = _mm_loadu_ps(m2[2]); v4sf row2 = _mm_loadu_ps(m2[2]);
@ -227,23 +227,23 @@ void MulMatricesSSE(float m1[4][4], float m2[4][4], float r[4][4])
// Fill tmp with four copies of leftrow[0] // Fill tmp with four copies of leftrow[0]
v4sf tmp = leftrow; v4sf tmp = leftrow;
tmp = _mm_shuffle_ps (tmp, tmp, 0); tmp = _mm_shuffle_ps(tmp, tmp, 0);
// Calculate the four first summands // Calculate the four first summands
v4sf destrow = tmp * row0; v4sf destrow = tmp * row0;
// Fill tmp with four copies of leftrow[1] // Fill tmp with four copies of leftrow[1]
tmp = leftrow; tmp = leftrow;
tmp = _mm_shuffle_ps (tmp, tmp, 1 + (1 << 2) + (1 << 4) + (1 << 6)); tmp = _mm_shuffle_ps(tmp, tmp, 1 + (1 << 2) + (1 << 4) + (1 << 6));
destrow += tmp * row1; destrow += tmp * row1;
// Fill tmp with four copies of leftrow[2] // Fill tmp with four copies of leftrow[2]
tmp = leftrow; tmp = leftrow;
tmp = _mm_shuffle_ps (tmp, tmp, 2 + (2 << 2) + (2 << 4) + (2 << 6)); tmp = _mm_shuffle_ps(tmp, tmp, 2 + (2 << 2) + (2 << 4) + (2 << 6));
destrow += tmp * row2; destrow += tmp * row2;
// Fill tmp with four copies of leftrow[3] // Fill tmp with four copies of leftrow[3]
tmp = leftrow; tmp = leftrow;
tmp = _mm_shuffle_ps (tmp, tmp, 3 + (3 << 2) + (3 << 4) + (3 << 6)); tmp = _mm_shuffle_ps(tmp, tmp, 3 + (3 << 2) + (3 << 4) + (3 << 6));
destrow += tmp * row3; destrow += tmp * row3;
__builtin_ia32_storeups(r[i], destrow); __builtin_ia32_storeups(r[i], destrow);
@ -252,105 +252,105 @@ void MulMatricesSSE(float m1[4][4], float m2[4][4], float r[4][4])
__asm __asm
{ {
mov eax, dword ptr[r] mov eax, dword ptr[r]
mov ecx, dword ptr[m1] mov ecx, dword ptr[m1]
mov edx, dword ptr[m2] mov edx, dword ptr[m2]
movaps xmm0, [edx] movaps xmm0, [edx]
movaps xmm1, [edx + 16] movaps xmm1, [edx + 16]
movaps xmm2, [edx + 32] movaps xmm2, [edx + 32]
movaps xmm3, [edx + 48] movaps xmm3, [edx + 48]
// r[0][0],r[0][1],r[0][2],r[0][3] // r[0][0],r[0][1],r[0][2],r[0][3]
movaps xmm4, xmmword ptr[ecx] movaps xmm4, xmmword ptr[ecx]
movaps xmm5, xmm4 movaps xmm5, xmm4
movaps xmm6, xmm4 movaps xmm6, xmm4
movaps xmm7, xmm4 movaps xmm7, xmm4
shufps xmm4, xmm4, 00000000b shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b shufps xmm7, xmm7, 11111111b
mulps xmm4, xmm0 mulps xmm4, xmm0
mulps xmm5, xmm1 mulps xmm5, xmm1
mulps xmm6, xmm2 mulps xmm6, xmm2
mulps xmm7, xmm3 mulps xmm7, xmm3
addps xmm4, xmm5 addps xmm4, xmm5
addps xmm4, xmm6 addps xmm4, xmm6
addps xmm4, xmm7 addps xmm4, xmm7
movaps xmmword ptr[eax], xmm4 movaps xmmword ptr[eax], xmm4
// r[1][0],r[1][1],r[1][2],r[1][3] // r[1][0],r[1][1],r[1][2],r[1][3]
movaps xmm4, xmmword ptr[ecx + 16] movaps xmm4, xmmword ptr[ecx + 16]
movaps xmm5, xmm4 movaps xmm5, xmm4
movaps xmm6, xmm4 movaps xmm6, xmm4
movaps xmm7, xmm4 movaps xmm7, xmm4
shufps xmm4, xmm4, 00000000b shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b shufps xmm7, xmm7, 11111111b
mulps xmm4, xmm0 mulps xmm4, xmm0
mulps xmm5, xmm1 mulps xmm5, xmm1
mulps xmm6, xmm2 mulps xmm6, xmm2
mulps xmm7, xmm3 mulps xmm7, xmm3
addps xmm4, xmm5 addps xmm4, xmm5
addps xmm4, xmm6 addps xmm4, xmm6
addps xmm4, xmm7 addps xmm4, xmm7
movaps xmmword ptr[eax + 16], xmm4 movaps xmmword ptr[eax + 16], xmm4
// r[2][0],r[2][1],r[2][2],r[2][3] // r[2][0],r[2][1],r[2][2],r[2][3]
movaps xmm4, xmmword ptr[ecx + 32] movaps xmm4, xmmword ptr[ecx + 32]
movaps xmm5, xmm4 movaps xmm5, xmm4
movaps xmm6, xmm4 movaps xmm6, xmm4
movaps xmm7, xmm4 movaps xmm7, xmm4
shufps xmm4, xmm4, 00000000b shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b shufps xmm7, xmm7, 11111111b
mulps xmm4, xmm0 mulps xmm4, xmm0
mulps xmm5, xmm1 mulps xmm5, xmm1
mulps xmm6, xmm2 mulps xmm6, xmm2
mulps xmm7, xmm3 mulps xmm7, xmm3
addps xmm4, xmm5 addps xmm4, xmm5
addps xmm4, xmm6 addps xmm4, xmm6
addps xmm4, xmm7 addps xmm4, xmm7
movaps xmmword ptr[eax + 32], xmm4 movaps xmmword ptr[eax + 32], xmm4
// r[3][0],r[3][1],r[3][2],r[3][3] // r[3][0],r[3][1],r[3][2],r[3][3]
movaps xmm4, xmmword ptr[ecx + 48] movaps xmm4, xmmword ptr[ecx + 48]
movaps xmm5, xmm4 movaps xmm5, xmm4
movaps xmm6, xmm4 movaps xmm6, xmm4
movaps xmm7, xmm4 movaps xmm7, xmm4
shufps xmm4, xmm4, 00000000b shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b shufps xmm7, xmm7, 11111111b
mulps xmm4, xmm0 mulps xmm4, xmm0
mulps xmm5, xmm1 mulps xmm5, xmm1
mulps xmm6, xmm2 mulps xmm6, xmm2
mulps xmm7, xmm3 mulps xmm7, xmm3
addps xmm4, xmm5 addps xmm4, xmm5
addps xmm4, xmm6 addps xmm4, xmm6
addps xmm4, xmm7 addps xmm4, xmm7
movaps xmmword ptr[eax + 48], xmm4 movaps xmmword ptr[eax + 48], xmm4
} }
#endif // _WIN32 #endif // _WIN32
} }
@ -383,9 +383,9 @@ void math_init()
} }
GLIDE64_CATCH GLIDE64_CATCH
{ return; } { return; }
// Check for SSE // Check for SSE
if (edx & (1 << 25)) if (edx & (1 << 25))
IsSSE = TRUE; IsSSE = TRUE;
#elif !defined(NO_ASM) && !defined(NOSSE) #elif !defined(NO_ASM) && !defined(NOSSE)
DWORD dwEdx; DWORD dwEdx;
__try __try
@ -393,8 +393,8 @@ void math_init()
__asm __asm
{ {
mov eax, 1 mov eax, 1
cpuid cpuid
mov dwEdx, edx mov dwEdx, edx
} }
} }
__except (EXCEPTION_EXECUTE_HANDLER) __except (EXCEPTION_EXECUTE_HANDLER)

10
Source/Project64-video/Combine.cpp
View File

@ -4665,7 +4665,7 @@ static void cc__t0_sub_prim_mul_shade_add_env__mul_shadea()
static void cc__t0_mul_shade__sub_env_mul_shadea_add_env() //Aded by Gonetz static void cc__t0_mul_shade__sub_env_mul_shadea_add_env() //Aded by Gonetz
{ {
if (rdp.tiles[rdp.cur_tile].format == 4) if (rdp.tiles(rdp.cur_tile).format == 4)
{ {
CCMB(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL, CCMB(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL_ADD_LOCAL,
GR_COMBINE_FACTOR_OTHER_ALPHA, GR_COMBINE_FACTOR_OTHER_ALPHA,
@ -4673,7 +4673,7 @@ static void cc__t0_mul_shade__sub_env_mul_shadea_add_env() //Aded by Gonetz
GR_COMBINE_OTHER_ITERATED); GR_COMBINE_OTHER_ITERATED);
CC_ENV(); CC_ENV();
} }
else if (rdp.tiles[rdp.cur_tile].format == 2) else if (rdp.tiles(rdp.cur_tile).format == 2)
{ {
CCMB(GR_COMBINE_FUNCTION_SCALE_OTHER, CCMB(GR_COMBINE_FUNCTION_SCALE_OTHER,
GR_COMBINE_FACTOR_LOCAL, GR_COMBINE_FACTOR_LOCAL,
@ -5820,7 +5820,7 @@ static void cc_prim_sub_env_mul__t1_sub_prim_mul_enva_add_t0__add_env()
SETSHADE_PRIM(); SETSHADE_PRIM();
if (cmb.combine_ext) if (cmb.combine_ext)
{ {
if (rdp.tiles[rdp.cur_tile].format > 2) if (rdp.tiles(rdp.cur_tile).format > 2)
{ {
T1CCMBEXT(GR_CMBX_LOCAL_TEXTURE_RGB, GR_FUNC_MODE_ZERO, T1CCMBEXT(GR_CMBX_LOCAL_TEXTURE_RGB, GR_FUNC_MODE_ZERO,
GR_CMBX_LOCAL_TEXTURE_RGB, GR_FUNC_MODE_ZERO, GR_CMBX_LOCAL_TEXTURE_RGB, GR_FUNC_MODE_ZERO,
@ -8769,7 +8769,7 @@ static void ac_t1()
GR_COMBINE_FACTOR_ONE, GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE, GR_COMBINE_LOCAL_NONE,
GR_COMBINE_OTHER_TEXTURE); GR_COMBINE_OTHER_TEXTURE);
if (g_settings->hacks(CSettings::hack_BAR) && rdp.tiles[rdp.cur_tile].format == 3) if (g_settings->hacks(CSettings::hack_BAR) && rdp.tiles(rdp.cur_tile).format == 3)
A_USE_T0(); A_USE_T0();
else else
A_USE_T1(); A_USE_T1();
@ -10038,7 +10038,7 @@ static void ac__t0_mul_t1__mul_prim()
GR_COMBINE_LOCAL_CONSTANT, GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_TEXTURE); GR_COMBINE_OTHER_TEXTURE);
CA_PRIM(); CA_PRIM();
if (voodoo.sup_large_tex || rdp.tiles[1].lr_s < 256) //hack for RR64 pause screen if (voodoo.sup_large_tex || rdp.tiles(1).lr_s < 256) //hack for RR64 pause screen
{ {
A_T0_MUL_T1(); A_T0_MUL_T1();
} }

240
Source/Project64-video/TexCache.cpp
View File

@ -170,11 +170,11 @@ void GetTexInfo(int id, int tile)
int wid_64, line, bpl; int wid_64, line, bpl;
// Get width and height // Get width and height
tile_width = rdp.tiles[tile].lr_s - rdp.tiles[tile].ul_s + 1; tile_width = rdp.tiles(tile).lr_s - rdp.tiles(tile).ul_s + 1;
tile_height = rdp.tiles[tile].lr_t - rdp.tiles[tile].ul_t + 1; tile_height = rdp.tiles(tile).lr_t - rdp.tiles(tile).ul_t + 1;
mask_width = (rdp.tiles[tile].mask_s == 0) ? (tile_width) : (1 << rdp.tiles[tile].mask_s); mask_width = (rdp.tiles(tile).mask_s == 0) ? (tile_width) : (1 << rdp.tiles(tile).mask_s);
mask_height = (rdp.tiles[tile].mask_t == 0) ? (tile_height) : (1 << rdp.tiles[tile].mask_t); mask_height = (rdp.tiles(tile).mask_t == 0) ? (tile_height) : (1 << rdp.tiles(tile).mask_t);
if (g_settings->alt_tex_size()) if (g_settings->alt_tex_size())
{ {
@ -183,32 +183,32 @@ void GetTexInfo(int id, int tile)
// textures. // textures.
// Get the width/height to load // Get the width/height to load
if ((rdp.tiles[tile].clamp_s && tile_width <= 256) || (mask_width > 256)) if ((rdp.tiles(tile).clamp_s && tile_width <= 256) || (mask_width > 256))
{ {
// loading width // loading width
width = minval(mask_width, tile_width); width = minval(mask_width, tile_width);
// actual width // actual width
rdp.tiles[tile].width = tile_width; rdp.tiles(tile).width = tile_width;
} }
else else
{ {
// wrap all the way // wrap all the way
width = minval(mask_width, tile_width); // changed from mask_width only width = minval(mask_width, tile_width); // changed from mask_width only
rdp.tiles[tile].width = width; rdp.tiles(tile).width = width;
} }
if ((rdp.tiles[tile].clamp_t && tile_height <= 256) || (mask_height > 256)) if ((rdp.tiles(tile).clamp_t && tile_height <= 256) || (mask_height > 256))
{ {
// loading height // loading height
height = minval(mask_height, tile_height); height = minval(mask_height, tile_height);
// actual height // actual height
rdp.tiles[tile].height = tile_height; rdp.tiles(tile).height = tile_height;
} }
else else
{ {
// wrap all the way // wrap all the way
height = minval(mask_height, tile_height); height = minval(mask_height, tile_height);
rdp.tiles[tile].height = height; rdp.tiles(tile).height = height;
} }
} }
else else
@ -224,52 +224,52 @@ void GetTexInfo(int id, int tile)
} }
// Get the width/height to load // Get the width/height to load
if ((rdp.tiles[tile].clamp_s && tile_width <= 256))//|| (mask_width > 256)) if ((rdp.tiles(tile).clamp_s && tile_width <= 256))//|| (mask_width > 256))
{ {
// loading width // loading width
width = minval(mask_width, tile_width); width = minval(mask_width, tile_width);
// actual width // actual width
rdp.tiles[tile].width = tile_width; rdp.tiles(tile).width = tile_width;
} }
else else
{ {
// wrap all the way // wrap all the way
width = mask_width; width = mask_width;
rdp.tiles[tile].width = mask_width; rdp.tiles(tile).width = mask_width;
} }
if ((rdp.tiles[tile].clamp_t && tile_height <= 256) || (mask_height > 256)) if ((rdp.tiles(tile).clamp_t && tile_height <= 256) || (mask_height > 256))
{ {
// loading height // loading height
height = minval(mask_height, tile_height); height = minval(mask_height, tile_height);
// actual height // actual height
rdp.tiles[tile].height = tile_height; rdp.tiles(tile).height = tile_height;
} }
else else
{ {
// wrap all the way // wrap all the way
height = mask_height; height = mask_height;
rdp.tiles[tile].height = mask_height; rdp.tiles(tile).height = mask_height;
} }
} }
// without any large texture fixing-up; for alignment // without any large texture fixing-up; for alignment
int real_image_width = rdp.tiles[tile].width; int real_image_width = rdp.tiles(tile).width;
int real_image_height = rdp.tiles[tile].height; int real_image_height = rdp.tiles(tile).height;
int crc_height = height; int crc_height = height;
if (rdp.timg.set_by == 1) if (rdp.timg.set_by == 1)
crc_height = tile_height; crc_height = tile_height;
bpl = width << rdp.tiles[tile].size >> 1; bpl = width << rdp.tiles(tile).size >> 1;
// ** COMMENT THIS TO DISABLE LARGE TEXTURES // ** COMMENT THIS TO DISABLE LARGE TEXTURES
#ifdef LARGE_TEXTURE_HANDLING #ifdef LARGE_TEXTURE_HANDLING
if (!voodoo.sup_large_tex && width > 256) if (!voodoo.sup_large_tex && width > 256)
{ {
info->splits = ((width - 1) >> 8) + 1; info->splits = ((width - 1) >> 8) + 1;
info->splitheight = rdp.tiles[tile].height; info->splitheight = rdp.tiles(tile).height;
rdp.tiles[tile].height *= info->splits; rdp.tiles(tile).height *= info->splits;
rdp.tiles[tile].width = 256; rdp.tiles(tile).width = 256;
width = 256; width = 256;
} }
else else
@ -280,19 +280,19 @@ void GetTexInfo(int id, int tile)
} }
WriteTrace(TraceRDP, TraceDebug, " | | |-+ Texture approved:"); WriteTrace(TraceRDP, TraceDebug, " | | |-+ Texture approved:");
WriteTrace(TraceRDP, TraceDebug, " | | | |- tmem: %08lx", rdp.tiles[tile].t_mem); WriteTrace(TraceRDP, TraceDebug, " | | | |- tmem: %08lx", rdp.tiles(tile).t_mem);
WriteTrace(TraceRDP, TraceDebug, " | | | |- load width: %d", width); WriteTrace(TraceRDP, TraceDebug, " | | | |- load width: %d", width);
WriteTrace(TraceRDP, TraceDebug, " | | | |- load height: %d", height); WriteTrace(TraceRDP, TraceDebug, " | | | |- load height: %d", height);
WriteTrace(TraceRDP, TraceDebug, " | | | |- actual width: %d", rdp.tiles[tile].width); WriteTrace(TraceRDP, TraceDebug, " | | | |- actual width: %d", rdp.tiles(tile).width);
WriteTrace(TraceRDP, TraceDebug, " | | | |- actual height: %d", rdp.tiles[tile].height); WriteTrace(TraceRDP, TraceDebug, " | | | |- actual height: %d", rdp.tiles(tile).height);
WriteTrace(TraceRDP, TraceDebug, " | | | |- size: %d", rdp.tiles[tile].size); WriteTrace(TraceRDP, TraceDebug, " | | | |- size: %d", rdp.tiles(tile).size);
WriteTrace(TraceRDP, TraceDebug, " | | | +- format: %d", rdp.tiles[tile].format); WriteTrace(TraceRDP, TraceDebug, " | | | +- format: %d", rdp.tiles(tile).format);
WriteTrace(TraceRDP, TraceDebug, " | | |- Calculating CRC... "); WriteTrace(TraceRDP, TraceDebug, " | | |- Calculating CRC... ");
// ** CRC CHECK // ** CRC CHECK
wid_64 = width << (rdp.tiles[tile].size) >> 1; wid_64 = width << (rdp.tiles(tile).size) >> 1;
if (rdp.tiles[tile].size == 3) if (rdp.tiles(tile).size == 3)
{ {
if (wid_64 & 15) wid_64 += 16; if (wid_64 & 15) wid_64 += 16;
wid_64 &= 0xFFFFFFF0; wid_64 &= 0xFFFFFFF0;
@ -304,20 +304,20 @@ void GetTexInfo(int id, int tile)
wid_64 = wid_64 >> 3; wid_64 = wid_64 >> 3;
// Texture too big for tmem & needs to wrap? (trees in mm) // Texture too big for tmem & needs to wrap? (trees in mm)
if (rdp.tiles[tile].t_mem + minval(height, tile_height) * (rdp.tiles[tile].line << 3) > 4096) if (rdp.tiles(tile).t_mem + minval(height, tile_height) * (rdp.tiles(tile).line << 3) > 4096)
{ {
WriteTrace(TraceRDP, TraceDebug, "TEXTURE WRAPS TMEM!!! "); WriteTrace(TraceRDP, TraceDebug, "TEXTURE WRAPS TMEM!!! ");
// calculate the y value that intersects at 4096 bytes // calculate the y value that intersects at 4096 bytes
int y = (4096 - rdp.tiles[tile].t_mem) / (rdp.tiles[tile].line << 3); int y = (4096 - rdp.tiles(tile).t_mem) / (rdp.tiles(tile).line << 3);
rdp.tiles[tile].clamp_t = 0; rdp.tiles(tile).clamp_t = 0;
rdp.tiles[tile].lr_t = rdp.tiles[tile].ul_t + y - 1; rdp.tiles(tile).lr_t = rdp.tiles(tile).ul_t + y - 1;
// calc mask // calc mask
int shift; int shift;
for (shift = 0; (1 << shift) < y; shift++); for (shift = 0; (1 << shift) < y; shift++);
rdp.tiles[tile].mask_t = shift; rdp.tiles(tile).mask_t = shift;
// restart the function // restart the function
WriteTrace(TraceRDP, TraceDebug, "restarting..."); WriteTrace(TraceRDP, TraceDebug, "restarting...");
@ -325,18 +325,18 @@ void GetTexInfo(int id, int tile)
return; return;
} }
line = rdp.tiles[tile].line; line = rdp.tiles(tile).line;
if (rdp.tiles[tile].size == 3) if (rdp.tiles(tile).size == 3)
line <<= 1; line <<= 1;
uint32_t crc = 0; uint32_t crc = 0;
if (g_settings->fast_crc()) if (g_settings->fast_crc())
{ {
line = (line - wid_64) << 3; line = (line - wid_64) << 3;
if (wid_64 < 1) wid_64 = 1; if (wid_64 < 1) wid_64 = 1;
uint8_t * addr = (((uint8_t*)rdp.tmem) + (rdp.tiles[tile].t_mem << 3)); uint8_t * addr = (((uint8_t*)rdp.tmem) + (rdp.tiles(tile).t_mem << 3));
if (crc_height > 0) // Check the CRC if (crc_height > 0) // Check the CRC
{ {
if (rdp.tiles[tile].size < 3) if (rdp.tiles(tile).size < 3)
crc = textureCRC(addr, wid_64, crc_height, line); crc = textureCRC(addr, wid_64, crc_height, line);
else //32b texture else //32b texture
{ {
@ -350,9 +350,9 @@ void GetTexInfo(int id, int tile)
else else
{ {
crc = 0xFFFFFFFF; crc = 0xFFFFFFFF;
uintptr_t addr = uintptr_t(rdp.tmem) + (rdp.tiles[tile].t_mem << 3); uintptr_t addr = uintptr_t(rdp.tmem) + (rdp.tiles(tile).t_mem << 3);
uint32_t line2 = maxval(line, 1); uint32_t line2 = maxval(line, 1);
if (rdp.tiles[tile].size < 3) if (rdp.tiles(tile).size < 3)
{ {
line2 <<= 3; line2 <<= 3;
for (int y = 0; y < crc_height; y++) for (int y = 0; y < crc_height; y++)
@ -377,19 +377,19 @@ void GetTexInfo(int id, int tile)
line = (line - wid_64) << 3; line = (line - wid_64) << 3;
if (wid_64 < 1) wid_64 = 1; if (wid_64 < 1) wid_64 = 1;
} }
if ((rdp.tiles[tile].size < 2) && (rdp.tlut_mode || rdp.tiles[tile].format == 2)) if ((rdp.tiles(tile).size < 2) && (rdp.tlut_mode || rdp.tiles(tile).format == 2))
{ {
if (rdp.tiles[tile].size == 0) if (rdp.tiles(tile).size == 0)
crc += rdp.pal_8_crc[rdp.tiles[tile].palette]; crc += rdp.pal_8_crc[rdp.tiles(tile).palette];
else else
crc += rdp.pal_256_crc; crc += rdp.pal_256_crc;
} }
WriteTrace(TraceRDP, TraceDebug, "Done. CRC is: %08lx.", crc); WriteTrace(TraceRDP, TraceDebug, "Done. CRC is: %08lx.", crc);
uint32_t flags = (rdp.tiles[tile].clamp_s << 23) | (rdp.tiles[tile].mirror_s << 22) | uint32_t flags = (rdp.tiles(tile).clamp_s << 23) | (rdp.tiles(tile).mirror_s << 22) |
(rdp.tiles[tile].mask_s << 18) | (rdp.tiles[tile].clamp_t << 17) | (rdp.tiles(tile).mask_s << 18) | (rdp.tiles(tile).clamp_t << 17) |
(rdp.tiles[tile].mirror_t << 16) | (rdp.tiles[tile].mask_t << 12); (rdp.tiles(tile).mirror_t << 16) | (rdp.tiles(tile).mask_t << 12);
info->real_image_width = real_image_width; info->real_image_width = real_image_width;
info->real_image_height = real_image_height; info->real_image_height = real_image_height;
@ -431,18 +431,18 @@ void GetTexInfo(int id, int tile)
} }
NODE *node = cachelut[crc >> 16]; NODE *node = cachelut[crc >> 16];
uint32_t mod_mask = (rdp.tiles[tile].format == 2) ? 0xFFFFFFFF : 0xF0F0F0F0; uint32_t mod_mask = (rdp.tiles(tile).format == 2) ? 0xFFFFFFFF : 0xF0F0F0F0;
while (node) while (node)
{ {
if (node->crc == crc) if (node->crc == crc)
{ {
cache = (CACHE_LUT*)node->data; cache = (CACHE_LUT*)node->data;
if (/*tex_found[id][node->tmu] == -1 && if (/*tex_found[id][node->tmu] == -1 &&
rdp.tiles[tile].palette == cache->palette && rdp.tiles(tile).palette == cache->palette &&
rdp.tiles[tile].format == cache->format && rdp.tiles(tile).format == cache->format &&
rdp.tiles[tile].size == cache->size &&*/ rdp.tiles(tile).size == cache->size &&*/
rdp.tiles[tile].width == cache->width && rdp.tiles(tile).width == cache->width &&
rdp.tiles[tile].height == cache->height && rdp.tiles(tile).height == cache->height &&
flags == cache->flags) flags == cache->flags)
{ {
if (!(mod + cache->mod) || (cache->mod == mod && if (!(mod + cache->mod) || (cache->mod == mod &&
@ -862,15 +862,15 @@ void TexCache()
int clamp_s, clamp_t; int clamp_s, clamp_t;
if (rdp.force_wrap && !rdp.texrecting) if (rdp.force_wrap && !rdp.texrecting)
{ {
clamp_s = rdp.tiles[tile].clamp_s && rdp.tiles[tile].lr_s - rdp.tiles[tile].ul_s < 256; clamp_s = rdp.tiles(tile).clamp_s && rdp.tiles(tile).lr_s - rdp.tiles(tile).ul_s < 256;
clamp_t = rdp.tiles[tile].clamp_t && rdp.tiles[tile].lr_t - rdp.tiles[tile].ul_t < 256; clamp_t = rdp.tiles(tile).clamp_t && rdp.tiles(tile).lr_t - rdp.tiles(tile).ul_t < 256;
} }
else else
{ {
clamp_s = (rdp.tiles[tile].clamp_s || rdp.tiles[tile].mask_s == 0) && clamp_s = (rdp.tiles(tile).clamp_s || rdp.tiles(tile).mask_s == 0) &&
rdp.tiles[tile].lr_s - rdp.tiles[tile].ul_s < 256; rdp.tiles(tile).lr_s - rdp.tiles(tile).ul_s < 256;
clamp_t = (rdp.tiles[tile].clamp_t || rdp.tiles[tile].mask_t == 0) && clamp_t = (rdp.tiles(tile).clamp_t || rdp.tiles(tile).mask_t == 0) &&
rdp.tiles[tile].lr_t - rdp.tiles[tile].ul_t < 256; rdp.tiles(tile).lr_t - rdp.tiles(tile).ul_t < 256;
} }
if (rdp.cur_cache[i]->f_mirror_s) if (rdp.cur_cache[i]->f_mirror_s)
@ -881,7 +881,7 @@ void TexCache()
mode_s = GR_TEXTURECLAMP_CLAMP; mode_s = GR_TEXTURECLAMP_CLAMP;
else else
{ {
if (rdp.tiles[tile].mirror_s && voodoo.sup_mirroring) if (rdp.tiles(tile).mirror_s && voodoo.sup_mirroring)
mode_s = GR_TEXTURECLAMP_MIRROR_EXT; mode_s = GR_TEXTURECLAMP_MIRROR_EXT;
else else
mode_s = GR_TEXTURECLAMP_WRAP; mode_s = GR_TEXTURECLAMP_WRAP;
@ -895,7 +895,7 @@ void TexCache()
mode_t = GR_TEXTURECLAMP_CLAMP; mode_t = GR_TEXTURECLAMP_CLAMP;
else else
{ {
if (rdp.tiles[tile].mirror_t && voodoo.sup_mirroring) if (rdp.tiles(tile).mirror_t && voodoo.sup_mirroring)
mode_t = GR_TEXTURECLAMP_MIRROR_EXT; mode_t = GR_TEXTURECLAMP_MIRROR_EXT;
else else
mode_t = GR_TEXTURECLAMP_WRAP; mode_t = GR_TEXTURECLAMP_WRAP;
@ -978,21 +978,21 @@ void LoadTex(int id, int tmu)
//!Hackalert //!Hackalert
//GoldenEye water texture. It has CI format in fact, but the game set it to RGBA //GoldenEye water texture. It has CI format in fact, but the game set it to RGBA
if (g_settings->hacks(CSettings::hack_GoldenEye) && rdp.tiles[td].format == 0 && rdp.tlut_mode == 2 && rdp.tiles[td].size == 2) if (g_settings->hacks(CSettings::hack_GoldenEye) && rdp.tiles(td).format == 0 && rdp.tlut_mode == 2 && rdp.tiles(td).size == 2)
{ {
rdp.tiles[td].format = 2; rdp.tiles(td).format = 2;
rdp.tiles[td].size = 1; rdp.tiles(td).size = 1;
} }
// Set the data // Set the data
cache->line = rdp.tiles[td].line; cache->line = rdp.tiles(td).line;
cache->addr = rdp.addr[rdp.tiles[td].t_mem]; cache->addr = rdp.addr[rdp.tiles(td).t_mem];
cache->crc = texinfo[id].crc; cache->crc = texinfo[id].crc;
cache->palette = rdp.tiles[td].palette; cache->palette = rdp.tiles(td).palette;
cache->width = rdp.tiles[td].width; cache->width = rdp.tiles(td).width;
cache->height = rdp.tiles[td].height; cache->height = rdp.tiles(td).height;
cache->format = rdp.tiles[td].format; cache->format = rdp.tiles(td).format;
cache->size = rdp.tiles[td].size; cache->size = rdp.tiles(td).size;
cache->tmem_addr = voodoo.tmem_ptr[tmu]; cache->tmem_addr = voodoo.tmem_ptr[tmu];
cache->set_by = rdp.timg.set_by; cache->set_by = rdp.timg.set_by;
cache->texrecting = rdp.texrecting; cache->texrecting = rdp.texrecting;
@ -1013,8 +1013,8 @@ void LoadTex(int id, int tmu)
cache->t_info.format = GFX_TEXFMT_ARGB_1555; cache->t_info.format = GFX_TEXFMT_ARGB_1555;
// Calculate lod and aspect // Calculate lod and aspect
uint32_t size_x = rdp.tiles[td].width; uint32_t size_x = rdp.tiles(td).width;
uint32_t size_y = rdp.tiles[td].height; uint32_t size_y = rdp.tiles(td).height;
// make size_x and size_y both powers of two // make size_x and size_y both powers of two
if (!voodoo.sup_large_tex) if (!voodoo.sup_large_tex)
@ -1032,9 +1032,9 @@ void LoadTex(int id, int tmu)
// Voodoo 1 support is all here, it will automatically mirror to the full extent. // Voodoo 1 support is all here, it will automatically mirror to the full extent.
if (!voodoo.sup_mirroring) if (!voodoo.sup_mirroring)
{ {
if (rdp.tiles[td].mirror_s && !rdp.tiles[td].clamp_s && (voodoo.sup_large_tex || size_x <= 128)) if (rdp.tiles(td).mirror_s && !rdp.tiles(td).clamp_s && (voodoo.sup_large_tex || size_x <= 128))
size_x <<= 1; size_x <<= 1;
if (rdp.tiles[td].mirror_t && !rdp.tiles[td].clamp_t && (voodoo.sup_large_tex || size_y <= 128)) if (rdp.tiles(td).mirror_t && !rdp.tiles(td).clamp_t && (voodoo.sup_large_tex || size_y <= 128))
size_y <<= 1; size_y <<= 1;
} }
@ -1236,50 +1236,50 @@ void LoadTex(int id, int tmu)
if (g_ghq_use) if (g_ghq_use)
{ {
int bpl; int bpl;
uint8_t* addr = (uint8_t*)(gfx.RDRAM + rdp.addr[rdp.tiles[td].t_mem]); uint8_t* addr = (uint8_t*)(gfx.RDRAM + rdp.addr[rdp.tiles(td).t_mem]);
int tile_width = texinfo[id].width; int tile_width = texinfo[id].width;
int tile_height = texinfo[id].height; int tile_height = texinfo[id].height;
LOAD_TILE_INFO &info = rdp.load_info[rdp.tiles[td].t_mem]; LOAD_TILE_INFO &info = rdp.load_info[rdp.tiles(td).t_mem];
if (rdp.timg.set_by == 1) if (rdp.timg.set_by == 1)
{ {
bpl = info.tex_width << info.tex_size >> 1; bpl = info.tex_width << info.tex_size >> 1;
addr += (info.tile_ul_t * bpl) + (((info.tile_ul_s << info.tex_size) + 1) >> 1); addr += (info.tile_ul_t * bpl) + (((info.tile_ul_s << info.tex_size) + 1) >> 1);
tile_width = minval(info.tile_width, info.tex_width); tile_width = minval(info.tile_width, info.tex_width);
if (info.tex_size > rdp.tiles[td].size) if (info.tex_size > rdp.tiles(td).size)
tile_width <<= info.tex_size - rdp.tiles[td].size; tile_width <<= info.tex_size - rdp.tiles(td).size;
if (rdp.tiles[td].lr_t > rdp.bg_image_height) if (rdp.tiles(td).lr_t > rdp.bg_image_height)
tile_height = rdp.bg_image_height - rdp.tiles[td].ul_t; tile_height = rdp.bg_image_height - rdp.tiles(td).ul_t;
else else
tile_height = info.tile_height; tile_height = info.tile_height;
} }
else else
{ {
if (rdp.tiles[td].size == 3) if (rdp.tiles(td).size == 3)
bpl = rdp.tiles[td].line << 4; bpl = rdp.tiles(td).line << 4;
else if (info.dxt == 0) else if (info.dxt == 0)
bpl = rdp.tiles[td].line << 3; bpl = rdp.tiles(td).line << 3;
else { else {
uint32_t dxt = info.dxt; uint32_t dxt = info.dxt;
if (dxt > 1) if (dxt > 1)
dxt = ReverseDXT(dxt, info.tile_width, texinfo[id].width, rdp.tiles[td].size); dxt = ReverseDXT(dxt, info.tile_width, texinfo[id].width, rdp.tiles(td).size);
bpl = dxt << 3; bpl = dxt << 3;
} }
} }
// uint8_t* addr = (uint8_t*)(gfx.RDRAM+rdp.addr[rdp.tiles[td].t_mem] + (rdp.tiles[td].ul_t * bpl) + (((rdp.tiles[td].ul_s<<rdp.tiles[td].size)+1)>>1)); // uint8_t* addr = (uint8_t*)(gfx.RDRAM+rdp.addr[rdp.tiles(td).t_mem] + (rdp.tiles(td).ul_t * bpl) + (((rdp.tiles(td).ul_s<<rdp.tiles(td).size)+1)>>1));
uint8_t * paladdr = 0; uint8_t * paladdr = 0;
uint16_t * palette = 0; uint16_t * palette = 0;
if ((rdp.tiles[td].size < 2) && (rdp.tlut_mode || rdp.tiles[td].format == 2)) if ((rdp.tiles(td).size < 2) && (rdp.tlut_mode || rdp.tiles(td).format == 2))
{ {
if (rdp.tiles[td].size == 1) if (rdp.tiles(td).size == 1)
paladdr = (uint8_t*)(rdp.pal_8_rice); paladdr = (uint8_t*)(rdp.pal_8_rice);
else if (g_settings->ghq_hirs_altcrc()) else if (g_settings->ghq_hirs_altcrc())
paladdr = (uint8_t*)(rdp.pal_8_rice + (rdp.tiles[td].palette << 5)); paladdr = (uint8_t*)(rdp.pal_8_rice + (rdp.tiles(td).palette << 5));
else else
paladdr = (uint8_t*)(rdp.pal_8_rice + (rdp.tiles[td].palette << 4)); paladdr = (uint8_t*)(rdp.pal_8_rice + (rdp.tiles(td).palette << 4));
palette = (rdp.pal_8 + (rdp.tiles[td].palette << 4)); palette = (rdp.pal_8 + (rdp.tiles(td).palette << 4));
} }
// XXX: Special combiner modes are ignored for hires textures // XXX: Special combiner modes are ignored for hires textures
@ -1291,8 +1291,8 @@ void LoadTex(int id, int tmu)
//g64_crc = CRC32( g64_crc, &cache->mod_color2, 4 ); // not used? //g64_crc = CRC32( g64_crc, &cache->mod_color2, 4 ); // not used?
g64_crc = CRC32(g64_crc, &cache->mod_factor, 4); g64_crc = CRC32(g64_crc, &cache->mod_factor, 4);
cache->ricecrc = ext_ghq_checksum(addr, tile_width, tile_height, (unsigned short)(rdp.tiles[td].format << 8 | rdp.tiles[td].size), bpl, paladdr); cache->ricecrc = ext_ghq_checksum(addr, tile_width, tile_height, (unsigned short)(rdp.tiles(td).format << 8 | rdp.tiles(td).size), bpl, paladdr);
WriteTrace(TraceRDP, TraceDebug, "CI RICE CRC. format: %d, size: %d, CRC: %08lx, PalCRC: %08lx", rdp.tiles[td].format, rdp.tiles[td].size, (uint32_t)(cache->ricecrc & 0xFFFFFFFF), (uint32_t)(cache->ricecrc >> 32)); WriteTrace(TraceRDP, TraceDebug, "CI RICE CRC. format: %d, size: %d, CRC: %08lx, PalCRC: %08lx", rdp.tiles(td).format, rdp.tiles(td).size, (uint32_t)(cache->ricecrc & 0xFFFFFFFF), (uint32_t)(cache->ricecrc >> 32));
if (ext_ghq_hirestex((uint64)g64_crc, cache->ricecrc, palette, &ghqTexInfo)) if (ext_ghq_hirestex((uint64)g64_crc, cache->ricecrc, palette, &ghqTexInfo))
{ {
cache->is_hires_tex = ghqTexInfo.is_hires_tex; cache->is_hires_tex = ghqTexInfo.is_hires_tex;
@ -1316,12 +1316,12 @@ void LoadTex(int id, int tmu)
start_dst <<= HIWORD(result); // 1st time, result is set to 0, but start_dst is 0 anyway so it doesn't matter start_dst <<= HIWORD(result); // 1st time, result is set to 0, but start_dst is 0 anyway so it doesn't matter
int start_src = i * 256; // start 256 more to the right int start_src = i * 256; // start 256 more to the right
start_src = start_src << (rdp.tiles[td].size) >> 1; start_src = start_src << (rdp.tiles(td).size) >> 1;
if (rdp.tiles[td].size == 3) if (rdp.tiles(td).size == 3)
start_src >>= 1; start_src >>= 1;
result = load_table[rdp.tiles[td].size][rdp.tiles[td].format] result = load_table[rdp.tiles(td).size][rdp.tiles(td).format]
(uintptr_t(texture) + start_dst, uintptr_t(rdp.tmem) + (rdp.tiles[td].t_mem << 3) + start_src, (uintptr_t(texture) + start_dst, uintptr_t(rdp.tmem) + (rdp.tiles(td).t_mem << 3) + start_src,
texinfo[id].wid_64, texinfo[id].height, texinfo[id].line, real_x, td); texinfo[id].wid_64, texinfo[id].height, texinfo[id].line, real_x, td);
uint32_t size = HIWORD(result); uint32_t size = HIWORD(result);
@ -1337,19 +1337,19 @@ void LoadTex(int id, int tmu)
// ** end texture splitting ** // ** end texture splitting **
else else
{ {
result = load_table[rdp.tiles[td].size][rdp.tiles[td].format] result = load_table[rdp.tiles(td).size][rdp.tiles(td).format]
(uintptr_t(texture), uintptr_t(rdp.tmem) + (rdp.tiles[td].t_mem << 3), (uintptr_t(texture), uintptr_t(rdp.tmem) + (rdp.tiles(td).t_mem << 3),
texinfo[id].wid_64, texinfo[id].height, texinfo[id].line, real_x, td); texinfo[id].wid_64, texinfo[id].height, texinfo[id].line, real_x, td);
uint32_t size = HIWORD(result); uint32_t size = HIWORD(result);
int min_x, min_y; int min_x, min_y;
if (rdp.tiles[td].mask_s != 0) if (rdp.tiles(td).mask_s != 0)
min_x = minval((int)real_x, 1 << rdp.tiles[td].mask_s); min_x = minval((int)real_x, 1 << rdp.tiles(td).mask_s);
else else
min_x = real_x; min_x = real_x;
if (rdp.tiles[td].mask_t != 0) if (rdp.tiles(td).mask_t != 0)
min_y = minval((int)real_y, 1 << rdp.tiles[td].mask_t); min_y = minval((int)real_y, 1 << rdp.tiles(td).mask_t);
else else
min_y = real_y; min_y = real_y;
@ -1366,28 +1366,28 @@ void LoadTex(int id, int tmu)
if (texinfo[id].width < (int)real_x) if (texinfo[id].width < (int)real_x)
{ {
if (rdp.tiles[td].mirror_s) if (rdp.tiles(td).mirror_s)
{ {
if (size == 1) if (size == 1)
Mirror16bS((texture), rdp.tiles[td].mask_s, Mirror16bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height); real_x, real_x, texinfo[id].height);
else if (size != 2) else if (size != 2)
Mirror8bS((texture), rdp.tiles[td].mask_s, Mirror8bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height); real_x, real_x, texinfo[id].height);
else else
Mirror32bS((texture), rdp.tiles[td].mask_s, Mirror32bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height); real_x, real_x, texinfo[id].height);
} }
else else
{ {
if (size == 1) if (size == 1)
Wrap16bS((texture), rdp.tiles[td].mask_s, Wrap16bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height); real_x, real_x, texinfo[id].height);
else if (size != 2) else if (size != 2)
Wrap8bS((texture), rdp.tiles[td].mask_s, Wrap8bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height); real_x, real_x, texinfo[id].height);
else else
Wrap32bS((texture), rdp.tiles[td].mask_s, Wrap32bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height); real_x, real_x, texinfo[id].height);
} }
} }
@ -1404,28 +1404,28 @@ void LoadTex(int id, int tmu)
if (texinfo[id].height < (int)real_y) if (texinfo[id].height < (int)real_y)
{ {
if (rdp.tiles[td].mirror_t) if (rdp.tiles(td).mirror_t)
{ {
if (size == 1) if (size == 1)
Mirror16bT((texture), rdp.tiles[td].mask_t, Mirror16bT((texture), rdp.tiles(td).mask_t,
real_y, real_x); real_y, real_x);
else if (size != 2) else if (size != 2)
Mirror8bT((texture), rdp.tiles[td].mask_t, Mirror8bT((texture), rdp.tiles(td).mask_t,
real_y, real_x); real_y, real_x);
else else
Mirror32bT((texture), rdp.tiles[td].mask_t, Mirror32bT((texture), rdp.tiles(td).mask_t,
real_y, real_x); real_y, real_x);
} }
else else
{ {
if (size == 1) if (size == 1)
Wrap16bT((texture), rdp.tiles[td].mask_t, Wrap16bT((texture), rdp.tiles(td).mask_t,
real_y, real_x); real_y, real_x);
else if (size != 2) else if (size != 2)
Wrap8bT((texture), rdp.tiles[td].mask_t, Wrap8bT((texture), rdp.tiles(td).mask_t,
real_y, real_x); real_y, real_x);
else else
Wrap32bT((texture), rdp.tiles[td].mask_t, Wrap32bT((texture), rdp.tiles(td).mask_t,
real_y, real_x); real_y, real_x);
} }
} }
@ -1597,9 +1597,9 @@ void LoadTex(int id, int tmu)
} }
else else
{ {
int tile_width = rdp.tiles[td].width; int tile_width = rdp.tiles(td).width;
if (rdp.timg.set_by == 1) if (rdp.timg.set_by == 1)
tile_width = rdp.load_info[rdp.tiles[td].t_mem].tex_width; tile_width = rdp.load_info[rdp.tiles(td).t_mem].tex_width;
float mult = float(ghqTexInfo.untiled_width / tile_width); float mult = float(ghqTexInfo.untiled_width / tile_width);
cache->c_scl_x *= mult; cache->c_scl_x *= mult;
cache->c_scl_y *= mult; cache->c_scl_y *= mult;
@ -1637,11 +1637,11 @@ void LoadTex(int id, int tmu)
} }
if (voodoo.sup_mirroring) if (voodoo.sup_mirroring)
{ {
if (rdp.tiles[td].mirror_s && texinfo[id].tile_width == 2 * texinfo[id].width) if (rdp.tiles(td).mirror_s && texinfo[id].tile_width == 2 * texinfo[id].width)
cache->f_mirror_s = TRUE; cache->f_mirror_s = TRUE;
else if (texinfo[id].tile_width >= 2 * texinfo[id].width) else if (texinfo[id].tile_width >= 2 * texinfo[id].width)
cache->f_wrap_s = TRUE; cache->f_wrap_s = TRUE;
if (rdp.tiles[td].mirror_t && texinfo[id].tile_height == 2 * texinfo[id].height) if (rdp.tiles(td).mirror_t && texinfo[id].tile_height == 2 * texinfo[id].height)
cache->f_mirror_t = TRUE; cache->f_mirror_t = TRUE;
else if (texinfo[id].tile_height >= 2 * texinfo[id].height) else if (texinfo[id].tile_height >= 2 * texinfo[id].height)
cache->f_wrap_t = TRUE; cache->f_wrap_t = TRUE;

2
Source/Project64-video/TexLoad16b.h
View File

@ -206,7 +206,7 @@ uint16_t yuv_to_rgb565(uint8_t y, uint8_t u, uint8_t v)
uint32_t Load16bYUV(uintptr_t dst, uintptr_t /*src*/, int /*wid_64*/, int /*height*/, int /*line*/, int /*real_width*/, int tile) uint32_t Load16bYUV(uintptr_t dst, uintptr_t /*src*/, int /*wid_64*/, int /*height*/, int /*line*/, int /*real_width*/, int tile)
{ {
uint32_t * mb = (uint32_t*)(gfx.RDRAM + rdp.addr[rdp.tiles[tile].t_mem]); //pointer to the macro block uint32_t * mb = (uint32_t*)(gfx.RDRAM + rdp.addr[rdp.tiles(tile).t_mem]); //pointer to the macro block
uint16_t * tex = (uint16_t*)dst; uint16_t * tex = (uint16_t*)dst;
uint16_t i; uint16_t i;
for (i = 0; i < 128; i++) for (i = 0; i < 128; i++)

8
Source/Project64-video/TexLoad32b.h
View File

@ -71,8 +71,8 @@ uint32_t Load32bRGBA(uintptr_t dst, uintptr_t src, int wid_64, int height, int l
// //
void LoadTile32b(uint32_t tile, uint32_t ul_s, uint32_t ul_t, uint32_t width, uint32_t height) void LoadTile32b(uint32_t tile, uint32_t ul_s, uint32_t ul_t, uint32_t width, uint32_t height)
{ {
const uint32_t line = rdp.tiles[tile].line << 2; const uint32_t line = rdp.tiles(tile).line << 2;
const uint32_t tbase = rdp.tiles[tile].t_mem << 2; const uint32_t tbase = rdp.tiles(tile).t_mem << 2;
const uint32_t addr = rdp.timg.addr >> 2; const uint32_t addr = rdp.timg.addr >> 2;
const uint32_t* src = (const uint32_t*)gfx.RDRAM; const uint32_t* src = (const uint32_t*)gfx.RDRAM;
uint16_t *tmem16 = (uint16_t*)rdp.tmem; uint16_t *tmem16 = (uint16_t*)rdp.tmem;
@ -100,10 +100,10 @@ void LoadTile32b(uint32_t tile, uint32_t ul_s, uint32_t ul_t, uint32_t width, ui
void LoadBlock32b(uint32_t tile, uint32_t ul_s, uint32_t ul_t, uint32_t lr_s, uint32_t dxt) void LoadBlock32b(uint32_t tile, uint32_t ul_s, uint32_t ul_t, uint32_t lr_s, uint32_t dxt)
{ {
const uint32_t * src = (const uint32_t*)gfx.RDRAM; const uint32_t * src = (const uint32_t*)gfx.RDRAM;
const uint32_t tb = rdp.tiles[tile].t_mem << 2; const uint32_t tb = rdp.tiles(tile).t_mem << 2;
const uint32_t tiwindwords = rdp.timg.width; const uint32_t tiwindwords = rdp.timg.width;
const uint32_t slindwords = ul_s; const uint32_t slindwords = ul_s;
const uint32_t line = rdp.tiles[tile].line << 2; const uint32_t line = rdp.tiles(tile).line << 2;
uint16_t *tmem16 = (uint16_t*)rdp.tmem; uint16_t *tmem16 = (uint16_t*)rdp.tmem;
uint32_t addr = rdp.timg.addr >> 2; uint32_t addr = rdp.timg.addr >> 2;

2
Source/Project64-video/TexLoad4b.h
View File

@ -567,7 +567,7 @@ uint32_t Load4bCI(uintptr_t dst, uintptr_t src, int wid_64, int height, int line
return /*(0 << 16) | */GFX_TEXFMT_ALPHA_INTENSITY_44; return /*(0 << 16) | */GFX_TEXFMT_ALPHA_INTENSITY_44;
} }
uintptr_t pal = uintptr_t(rdp.pal_8 + (rdp.tiles[tile].palette << 4)); uintptr_t pal = uintptr_t(rdp.pal_8 + (rdp.tiles(tile).palette << 4));
if (rdp.tlut_mode == 2) if (rdp.tlut_mode == 2)
{ {
ext <<= 1; ext <<= 1;

60
Source/Project64-video/Util.cpp
View File

@ -336,8 +336,8 @@ void draw_tri(VERTEX **vtx, uint16_t linew)
// Fix texture coordinates // Fix texture coordinates
if (!v->uv_scaled) if (!v->uv_scaled)
{ {
v->ou *= rdp.tiles[rdp.cur_tile].s_scale; v->ou *= rdp.tiles(rdp.cur_tile).s_scale;
v->ov *= rdp.tiles[rdp.cur_tile].t_scale; v->ov *= rdp.tiles(rdp.cur_tile).t_scale;
v->uv_scaled = 1; v->uv_scaled = 1;
if (!rdp.Persp_en) if (!rdp.Persp_en)
{ {
@ -357,35 +357,35 @@ void draw_tri(VERTEX **vtx, uint16_t linew)
v->v0 += rdp.aTBuffTex[0]->v_shift + rdp.aTBuffTex[0]->tile_ult; v->v0 += rdp.aTBuffTex[0]->v_shift + rdp.aTBuffTex[0]->tile_ult;
} }
if (rdp.tiles[rdp.cur_tile].shift_s) if (rdp.tiles(rdp.cur_tile).shift_s)
{ {
if (rdp.tiles[rdp.cur_tile].shift_s > 10) if (rdp.tiles(rdp.cur_tile).shift_s > 10)
v->u0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_s)); v->u0 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile).shift_s));
else else
v->u0 /= (float)(1 << rdp.tiles[rdp.cur_tile].shift_s); v->u0 /= (float)(1 << rdp.tiles(rdp.cur_tile).shift_s);
} }
if (rdp.tiles[rdp.cur_tile].shift_t) if (rdp.tiles(rdp.cur_tile).shift_t)
{ {
if (rdp.tiles[rdp.cur_tile].shift_t > 10) if (rdp.tiles(rdp.cur_tile).shift_t > 10)
v->v0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_t)); v->v0 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile).shift_t));
else else
v->v0 /= (float)(1 << rdp.tiles[rdp.cur_tile].shift_t); v->v0 /= (float)(1 << rdp.tiles(rdp.cur_tile).shift_t);
} }
if (rdp.aTBuffTex[0]) if (rdp.aTBuffTex[0])
{ {
if (rdp.aTBuffTex[0]->tile_uls != (int)rdp.tiles[rdp.cur_tile].f_ul_s) if (rdp.aTBuffTex[0]->tile_uls != (int)rdp.tiles(rdp.cur_tile).f_ul_s)
v->u0 -= rdp.tiles[rdp.cur_tile].f_ul_s; v->u0 -= rdp.tiles(rdp.cur_tile).f_ul_s;
if (rdp.aTBuffTex[0]->tile_ult != (int)rdp.tiles[rdp.cur_tile].f_ul_t || g_settings->hacks(CSettings::hack_Megaman)) if (rdp.aTBuffTex[0]->tile_ult != (int)rdp.tiles(rdp.cur_tile).f_ul_t || g_settings->hacks(CSettings::hack_Megaman))
v->v0 -= rdp.tiles[rdp.cur_tile].f_ul_t; //required for megaman (boss special attack) v->v0 -= rdp.tiles(rdp.cur_tile).f_ul_t; //required for megaman (boss special attack)
v->u0 *= rdp.aTBuffTex[0]->u_scale; v->u0 *= rdp.aTBuffTex[0]->u_scale;
v->v0 *= rdp.aTBuffTex[0]->v_scale; v->v0 *= rdp.aTBuffTex[0]->v_scale;
WriteTrace(TraceRDP, TraceVerbose, "tbuff_tex t0: (%f, %f)->(%f, %f)", v->ou, v->ov, v->u0, v->v0); WriteTrace(TraceRDP, TraceVerbose, "tbuff_tex t0: (%f, %f)->(%f, %f)", v->ou, v->ov, v->u0, v->v0);
} }
else else
{ {
v->u0 -= rdp.tiles[rdp.cur_tile].f_ul_s; v->u0 -= rdp.tiles(rdp.cur_tile).f_ul_s;
v->v0 -= rdp.tiles[rdp.cur_tile].f_ul_t; v->v0 -= rdp.tiles(rdp.cur_tile).f_ul_t;
v->u0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_x * v->u0; v->u0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_x * v->u0;
v->v0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_y * v->v0; v->v0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_y * v->v0;
} }
@ -400,33 +400,33 @@ void draw_tri(VERTEX **vtx, uint16_t linew)
v->u1 += rdp.aTBuffTex[1]->u_shift + rdp.aTBuffTex[1]->tile_uls; v->u1 += rdp.aTBuffTex[1]->u_shift + rdp.aTBuffTex[1]->tile_uls;
v->v1 += rdp.aTBuffTex[1]->v_shift + rdp.aTBuffTex[1]->tile_ult; v->v1 += rdp.aTBuffTex[1]->v_shift + rdp.aTBuffTex[1]->tile_ult;
} }
if (rdp.tiles[rdp.cur_tile + 1].shift_s) if (rdp.tiles(rdp.cur_tile + 1).shift_s)
{ {
if (rdp.tiles[rdp.cur_tile + 1].shift_s > 10) if (rdp.tiles(rdp.cur_tile + 1).shift_s > 10)
v->u1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_s)); v->u1 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile + 1).shift_s));
else else
v->u1 /= (float)(1 << rdp.tiles[rdp.cur_tile + 1].shift_s); v->u1 /= (float)(1 << rdp.tiles(rdp.cur_tile + 1).shift_s);
} }
if (rdp.tiles[rdp.cur_tile + 1].shift_t) if (rdp.tiles(rdp.cur_tile + 1).shift_t)
{ {
if (rdp.tiles[rdp.cur_tile + 1].shift_t > 10) if (rdp.tiles(rdp.cur_tile + 1).shift_t > 10)
v->v1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_t)); v->v1 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile + 1).shift_t));
else else
v->v1 /= (float)(1 << rdp.tiles[rdp.cur_tile + 1].shift_t); v->v1 /= (float)(1 << rdp.tiles(rdp.cur_tile + 1).shift_t);
} }
if (rdp.aTBuffTex[1]) if (rdp.aTBuffTex[1])
{ {
if (rdp.aTBuffTex[1]->tile_uls != (int)rdp.tiles[rdp.cur_tile].f_ul_s) if (rdp.aTBuffTex[1]->tile_uls != (int)rdp.tiles(rdp.cur_tile).f_ul_s)
v->u1 -= rdp.tiles[rdp.cur_tile].f_ul_s; v->u1 -= rdp.tiles(rdp.cur_tile).f_ul_s;
v->u1 *= rdp.aTBuffTex[1]->u_scale; v->u1 *= rdp.aTBuffTex[1]->u_scale;
v->v1 *= rdp.aTBuffTex[1]->v_scale; v->v1 *= rdp.aTBuffTex[1]->v_scale;
WriteTrace(TraceRDP, TraceVerbose, "tbuff_tex t1: (%f, %f)->(%f, %f)", v->ou, v->ov, v->u1, v->v1); WriteTrace(TraceRDP, TraceVerbose, "tbuff_tex t1: (%f, %f)->(%f, %f)", v->ou, v->ov, v->u1, v->v1);
} }
else else
{ {
v->u1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_s; v->u1 -= rdp.tiles(rdp.cur_tile + 1).f_ul_s;
v->v1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_t; v->v1 -= rdp.tiles(rdp.cur_tile + 1).f_ul_t;
v->u1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_x * v->u1; v->u1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_x * v->u1;
v->v1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_y * v->v1; v->v1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_y * v->v1;
} }
@ -929,8 +929,8 @@ static void CalculateLOD(VERTEX *v, int n)
float deltaX, deltaY; float deltaX, deltaY;
double deltaTexels, deltaPixels, lodFactor = 0; double deltaTexels, deltaPixels, lodFactor = 0;
double intptr; double intptr;
float s_scale = rdp.tiles[rdp.cur_tile].width / 255.0f; float s_scale = rdp.tiles(rdp.cur_tile).width / 255.0f;
float t_scale = rdp.tiles[rdp.cur_tile].height / 255.0f; float t_scale = rdp.tiles(rdp.cur_tile).height / 255.0f;
if (g_settings->lodmode() == CSettings::LOD_Fast) if (g_settings->lodmode() == CSettings::LOD_Fast)
{ {
deltaS = (v[1].u0 / v[1].q - v[0].u0 / v[0].q) * s_scale; deltaS = (v[1].u0 / v[1].q - v[0].u0 / v[0].q) * s_scale;

148
Source/Project64-video/rdp.cpp
View File

@ -468,7 +468,7 @@ void CRDP::free()
maincimg[0].addr = maincimg[1].addr = last_drawn_ci_addr = 0x7FFFFFFF; maincimg[0].addr = maincimg[1].addr = last_drawn_ci_addr = 0x7FFFFFFF;
memset(&timg, 0, sizeof(timg)); memset(&timg, 0, sizeof(timg));
memset(tiles, 0, sizeof(tiles)); memset(m_tiles, 0, sizeof(m_tiles));
memset(tmem, 0, sizeof(tmem)); memset(tmem, 0, sizeof(tmem));
memset(addr, 0, sizeof(addr)); memset(addr, 0, sizeof(addr));
memset(load_info, 0, sizeof(load_info)); memset(load_info, 0, sizeof(load_info));
@ -864,7 +864,7 @@ EXPORT void CALL ProcessDList(void)
if (g_settings->ucode() == CSettings::ucode_Turbo3d) if (g_settings->ucode() == CSettings::ucode_Turbo3d)
{ {
Turbo3D(); Turbo3D();
} }
else else
{ {
// MAIN PROCESSING LOOP // MAIN PROCESSING LOOP
@ -946,7 +946,7 @@ EXPORT void CALL ProcessDList(void)
CI_SET = FALSE; CI_SET = FALSE;
} }
WriteTrace(TraceRDP, TraceDebug, "ProcessDList end"); WriteTrace(TraceRDP, TraceDebug, "ProcessDList end");
} }
// undef - undefined instruction, always ignore // undef - undefined instruction, always ignore
void undef() void undef()
@ -992,8 +992,8 @@ void ys_memrect()
WriteTrace(TraceRDP, TraceDebug, " off_y: %d", off_y); WriteTrace(TraceRDP, TraceDebug, " off_y: %d", off_y);
uint32_t y, width = lr_x - ul_x; uint32_t y, width = lr_x - ul_x;
uint32_t tex_width = rdp.tiles[tile].line << 3; uint32_t tex_width = rdp.tiles(tile).line << 3;
uint8_t * texaddr = gfx.RDRAM + rdp.addr[rdp.tiles[tile].t_mem] + tex_width*off_y + off_x; uint8_t * texaddr = gfx.RDRAM + rdp.addr[rdp.tiles(tile).t_mem] + tex_width*off_y + off_x;
uint8_t * fbaddr = gfx.RDRAM + rdp.cimg + ul_x; uint8_t * fbaddr = gfx.RDRAM + rdp.cimg + ul_x;
for (y = ul_y; y < lr_y; y++) { for (y = ul_y; y < lr_y; y++) {
@ -1326,7 +1326,7 @@ void rdp_texrect()
{ {
float sx = 1, sy = 1; float sx = 1, sy = 1;
int x_i = off_x_i, y_i = off_y_i; int x_i = off_x_i, y_i = off_y_i;
TILE & tile = rdp.tiles[rdp.cur_tile + i]; TILE & tile = rdp.tiles(rdp.cur_tile + i);
//shifting //shifting
if (tile.shift_s) if (tile.shift_s)
{ {
@ -1752,7 +1752,7 @@ void load_palette(uint32_t addr, uint16_t start, uint16_t count)
void rdp_loadtlut() void rdp_loadtlut()
{ {
uint32_t tile = (rdp.cmd1 >> 24) & 0x07; uint32_t tile = (rdp.cmd1 >> 24) & 0x07;
uint16_t start = rdp.tiles[tile].t_mem - 256; // starting location in the palettes uint16_t start = rdp.tiles(tile).t_mem - 256; // starting location in the palettes
// uint16_t start = ((uint16_t)(rdp.cmd1 >> 2) & 0x3FF) + 1; // uint16_t start = ((uint16_t)(rdp.cmd1 >> 2) & 0x3FF) + 1;
uint16_t count = ((uint16_t)(rdp.cmd1 >> 14) & 0x3FF) + 1; // number to copy uint16_t count = ((uint16_t)(rdp.cmd1 >> 14) & 0x3FF) + 1; // number to copy
@ -1794,8 +1794,8 @@ void rdp_settilesize()
uint32_t tile = (rdp.cmd1 >> 24) & 0x07; uint32_t tile = (rdp.cmd1 >> 24) & 0x07;
rdp.last_tile_size = tile; rdp.last_tile_size = tile;
rdp.tiles[tile].f_ul_s = (float)((rdp.cmd0 >> 12) & 0xFFF) / 4.0f; rdp.tiles(tile).f_ul_s = (float)((rdp.cmd0 >> 12) & 0xFFF) / 4.0f;
rdp.tiles[tile].f_ul_t = (float)(rdp.cmd0 & 0xFFF) / 4.0f; rdp.tiles(tile).f_ul_t = (float)(rdp.cmd0 & 0xFFF) / 4.0f;
int ul_s = (rdp.cmd0 >> 14) & 0x03ff; int ul_s = (rdp.cmd0 >> 14) & 0x03ff;
int ul_t = (rdp.cmd0 >> 2) & 0x03ff; int ul_t = (rdp.cmd0 >> 2) & 0x03ff;
@ -1816,32 +1816,32 @@ void rdp_settilesize()
if (tile_set) if (tile_set)
{ {
// coords in 10.2 format // coords in 10.2 format
rdp.tiles[tile].ul_s = ul_s; rdp.tiles(tile).ul_s = ul_s;
rdp.tiles[tile].ul_t = ul_t; rdp.tiles(tile).ul_t = ul_t;
rdp.tiles[tile].lr_s = lr_s; rdp.tiles(tile).lr_s = lr_s;
rdp.tiles[tile].lr_t = lr_t; rdp.tiles(tile).lr_t = lr_t;
tile_set = 0; tile_set = 0;
} }
} }
else else
{ {
// coords in 10.2 format // coords in 10.2 format
rdp.tiles[tile].ul_s = ul_s; rdp.tiles(tile).ul_s = ul_s;
rdp.tiles[tile].ul_t = ul_t; rdp.tiles(tile).ul_t = ul_t;
rdp.tiles[tile].lr_s = lr_s; rdp.tiles(tile).lr_s = lr_s;
rdp.tiles[tile].lr_t = lr_t; rdp.tiles(tile).lr_t = lr_t;
} }
// handle wrapping // handle wrapping
if (rdp.tiles[tile].lr_s < rdp.tiles[tile].ul_s) rdp.tiles[tile].lr_s += 0x400; if (rdp.tiles(tile).lr_s < rdp.tiles(tile).ul_s) rdp.tiles(tile).lr_s += 0x400;
if (rdp.tiles[tile].lr_t < rdp.tiles[tile].ul_t) rdp.tiles[tile].lr_t += 0x400; if (rdp.tiles(tile).lr_t < rdp.tiles(tile).ul_t) rdp.tiles(tile).lr_t += 0x400;
rdp.update |= UPDATE_TEXTURE; rdp.update |= UPDATE_TEXTURE;
rdp.first = 1; rdp.first = 1;
WriteTrace(TraceRDP, TraceDebug, "settilesize: tile: %d, ul_s: %d, ul_t: %d, lr_s: %d, lr_t: %d, f_ul_s: %f, f_ul_t: %f", WriteTrace(TraceRDP, TraceDebug, "settilesize: tile: %d, ul_s: %d, ul_t: %d, lr_s: %d, lr_t: %d, f_ul_s: %f, f_ul_t: %f",
tile, ul_s, ul_t, lr_s, lr_t, rdp.tiles[tile].f_ul_s, rdp.tiles[tile].f_ul_t); tile, ul_s, ul_t, lr_s, lr_t, rdp.tiles(tile).f_ul_s, rdp.tiles(tile).f_ul_t);
} }
void setTBufTex(uint16_t t_mem, uint32_t cnt) void setTBufTex(uint16_t t_mem, uint32_t cnt)
@ -2019,7 +2019,7 @@ void rdp_loadblock()
ucode5_texshiftcount++; ucode5_texshiftcount++;
} }
rdp.addr[rdp.tiles[tile].t_mem] = rdp.timg.addr; rdp.addr[rdp.tiles(tile).t_mem] = rdp.timg.addr;
// ** DXT is used for swapping every other line // ** DXT is used for swapping every other line
/* double fdxt = (double)0x8000000F/(double)((uint32_t)(2047/(dxt-1))); // F for error /* double fdxt = (double)0x8000000F/(double)((uint32_t)(2047/(dxt-1))); // F for error
@ -2035,13 +2035,13 @@ void rdp_loadblock()
uint16_t ul_s = (uint16_t)((rdp.cmd0 >> 14) & 0x3FF); uint16_t ul_s = (uint16_t)((rdp.cmd0 >> 14) & 0x3FF);
uint16_t ul_t = (uint16_t)((rdp.cmd0 >> 2) & 0x3FF); uint16_t ul_t = (uint16_t)((rdp.cmd0 >> 2) & 0x3FF);
rdp.tiles[tile].ul_s = ul_s; rdp.tiles(tile).ul_s = ul_s;
rdp.tiles[tile].ul_t = ul_t; rdp.tiles(tile).ul_t = ul_t;
rdp.tiles[tile].lr_s = lr_s; rdp.tiles(tile).lr_s = lr_s;
rdp.timg.set_by = 0; // load block rdp.timg.set_by = 0; // load block
LOAD_TILE_INFO &info = rdp.load_info[rdp.tiles[tile].t_mem]; LOAD_TILE_INFO &info = rdp.load_info[rdp.tiles(tile).t_mem];
info.tile_width = lr_s; info.tile_width = lr_s;
info.dxt = dxt; info.dxt = dxt;
@ -2058,14 +2058,14 @@ void rdp_loadblock()
//angrylion's advice to use ul_s in texture image offset and cnt calculations. //angrylion's advice to use ul_s in texture image offset and cnt calculations.
//Helps to fix Vigilante 8 jpeg backgrounds and logos //Helps to fix Vigilante 8 jpeg backgrounds and logos
uint32_t off = rdp.timg.addr + (ul_s << rdp.tiles[tile].size >> 1); uint32_t off = rdp.timg.addr + (ul_s << rdp.tiles(tile).size >> 1);
unsigned char *dst = ((unsigned char *)rdp.tmem) + (rdp.tiles[tile].t_mem << 3); unsigned char *dst = ((unsigned char *)rdp.tmem) + (rdp.tiles(tile).t_mem << 3);
uint32_t cnt = lr_s - ul_s + 1; uint32_t cnt = lr_s - ul_s + 1;
if (rdp.tiles[tile].size == 3) if (rdp.tiles(tile).size == 3)
cnt <<= 1; cnt <<= 1;
if (((rdp.tiles[tile].t_mem + cnt) << 3) > sizeof(rdp.tmem)) { if (((rdp.tiles(tile).t_mem + cnt) << 3) > sizeof(rdp.tmem)) {
cnt = (sizeof(rdp.tmem) >> 3) - (rdp.tiles[tile].t_mem); cnt = (sizeof(rdp.tmem) >> 3) - (rdp.tiles(tile).t_mem);
} }
if (rdp.timg.size == 3) if (rdp.timg.size == 3)
@ -2074,7 +2074,7 @@ void rdp_loadblock()
loadBlock((uint32_t *)gfx.RDRAM, (uint32_t *)dst, off, _dxt, cnt); loadBlock((uint32_t *)gfx.RDRAM, (uint32_t *)dst, off, _dxt, cnt);
rdp.timg.addr += cnt << 3; rdp.timg.addr += cnt << 3;
rdp.tiles[tile].lr_t = ul_t + ((dxt*cnt) >> 11); rdp.tiles(tile).lr_t = ul_t + ((dxt*cnt) >> 11);
rdp.update |= UPDATE_TEXTURE; rdp.update |= UPDATE_TEXTURE;
@ -2084,7 +2084,7 @@ void rdp_loadblock()
if (g_settings->fb_hwfbe_enabled()) if (g_settings->fb_hwfbe_enabled())
{ {
setTBufTex(rdp.tiles[tile].t_mem, cnt); setTBufTex(rdp.tiles(tile).t_mem, cnt);
} }
} }
@ -2224,7 +2224,7 @@ void rdp_loadtile()
uint32_t tile = (uint32_t)((rdp.cmd1 >> 24) & 0x07); uint32_t tile = (uint32_t)((rdp.cmd1 >> 24) & 0x07);
rdp.addr[rdp.tiles[tile].t_mem] = rdp.timg.addr; rdp.addr[rdp.tiles(tile).t_mem] = rdp.timg.addr;
uint16_t ul_s = (uint16_t)((rdp.cmd0 >> 14) & 0x03FF); uint16_t ul_s = (uint16_t)((rdp.cmd0 >> 14) & 0x03FF);
uint16_t ul_t = (uint16_t)((rdp.cmd0 >> 2) & 0x03FF); uint16_t ul_t = (uint16_t)((rdp.cmd0 >> 2) & 0x03FF);
@ -2235,18 +2235,18 @@ void rdp_loadtile()
if (wrong_tile >= 0) //there was a tile with zero length if (wrong_tile >= 0) //there was a tile with zero length
{ {
rdp.tiles[wrong_tile].lr_s = lr_s; rdp.tiles(wrong_tile).lr_s = lr_s;
if (rdp.tiles[tile].size > rdp.tiles[wrong_tile].size) if (rdp.tiles(tile).size > rdp.tiles(wrong_tile).size)
rdp.tiles[wrong_tile].lr_s <<= (rdp.tiles[tile].size - rdp.tiles[wrong_tile].size); rdp.tiles(wrong_tile).lr_s <<= (rdp.tiles(tile).size - rdp.tiles(wrong_tile).size);
else if (rdp.tiles[tile].size < rdp.tiles[wrong_tile].size) else if (rdp.tiles(tile).size < rdp.tiles(wrong_tile).size)
rdp.tiles[wrong_tile].lr_s >>= (rdp.tiles[wrong_tile].size - rdp.tiles[tile].size); rdp.tiles(wrong_tile).lr_s >>= (rdp.tiles(wrong_tile).size - rdp.tiles(tile).size);
rdp.tiles[wrong_tile].lr_t = lr_t; rdp.tiles(wrong_tile).lr_t = lr_t;
rdp.tiles[wrong_tile].mask_s = rdp.tiles[wrong_tile].mask_t = 0; rdp.tiles(wrong_tile).mask_s = rdp.tiles(wrong_tile).mask_t = 0;
// wrong_tile = -1; // wrong_tile = -1;
} }
if (rdp.tbuff_tex)// && (rdp.tiles[tile].format == 0)) if (rdp.tbuff_tex)// && (rdp.tiles(tile).format == 0))
{ {
WriteTrace(TraceRDP, TraceDebug, "loadtile: tbuff_tex ul_s: %d, ul_t:%d", ul_s, ul_t); WriteTrace(TraceRDP, TraceDebug, "loadtile: tbuff_tex ul_s: %d, ul_t:%d", ul_s, ul_t);
rdp.tbuff_tex->tile_uls = ul_s; rdp.tbuff_tex->tile_uls = ul_s;
@ -2255,20 +2255,20 @@ void rdp_loadtile()
if (g_settings->hacks(CSettings::hack_Tonic) && tile == 7) if (g_settings->hacks(CSettings::hack_Tonic) && tile == 7)
{ {
rdp.tiles[0].ul_s = ul_s; rdp.tiles(0).ul_s = ul_s;
rdp.tiles[0].ul_t = ul_t; rdp.tiles(0).ul_t = ul_t;
rdp.tiles[0].lr_s = lr_s; rdp.tiles(0).lr_s = lr_s;
rdp.tiles[0].lr_t = lr_t; rdp.tiles(0).lr_t = lr_t;
} }
uint32_t height = lr_t - ul_t + 1; // get height uint32_t height = lr_t - ul_t + 1; // get height
uint32_t width = lr_s - ul_s + 1; uint32_t width = lr_s - ul_s + 1;
LOAD_TILE_INFO &info = rdp.load_info[rdp.tiles[tile].t_mem]; LOAD_TILE_INFO &info = rdp.load_info[rdp.tiles(tile).t_mem];
info.tile_ul_s = ul_s; info.tile_ul_s = ul_s;
info.tile_ul_t = ul_t; info.tile_ul_t = ul_t;
info.tile_width = (rdp.tiles[tile].mask_s ? minval((uint16_t)width, 1 << rdp.tiles[tile].mask_s) : (uint16_t)width); info.tile_width = (rdp.tiles(tile).mask_s ? minval((uint16_t)width, 1 << rdp.tiles(tile).mask_s) : (uint16_t)width);
info.tile_height = (rdp.tiles[tile].mask_t ? minval((uint16_t)height, 1 << rdp.tiles[tile].mask_t) : (uint16_t)height); info.tile_height = (rdp.tiles(tile).mask_t ? minval((uint16_t)height, 1 << rdp.tiles(tile).mask_t) : (uint16_t)height);
if (g_settings->hacks(CSettings::hack_MK64)) if (g_settings->hacks(CSettings::hack_MK64))
{ {
if (info.tile_width % 2) if (info.tile_width % 2)
@ -2283,9 +2283,9 @@ void rdp_loadtile()
info.tex_width = rdp.timg.width; info.tex_width = rdp.timg.width;
info.tex_size = rdp.timg.size; info.tex_size = rdp.timg.size;
int line_n = rdp.timg.width << rdp.tiles[tile].size >> 1; int line_n = rdp.timg.width << rdp.tiles(tile).size >> 1;
uint32_t offs = ul_t * line_n; uint32_t offs = ul_t * line_n;
offs += ul_s << rdp.tiles[tile].size >> 1; offs += ul_s << rdp.tiles(tile).size >> 1;
offs += rdp.timg.addr; offs += rdp.timg.addr;
if (offs >= BMASK) if (offs >= BMASK)
return; return;
@ -2302,8 +2302,8 @@ void rdp_loadtile()
if (height == 0) if (height == 0)
return; return;
uint32_t wid_64 = rdp.tiles[tile].line; uint32_t wid_64 = rdp.tiles(tile).line;
unsigned char *dst = ((unsigned char *)rdp.tmem) + (rdp.tiles[tile].t_mem << 3); unsigned char *dst = ((unsigned char *)rdp.tmem) + (rdp.tiles(tile).t_mem << 3);
unsigned char *end = ((unsigned char *)rdp.tmem) + 4096 - (wid_64 << 3); unsigned char *end = ((unsigned char *)rdp.tmem) + 4096 - (wid_64 << 3);
loadTile((uint32_t *)gfx.RDRAM, (uint32_t *)dst, wid_64, height, line_n, offs, (uint32_t *)end); loadTile((uint32_t *)gfx.RDRAM, (uint32_t *)dst, wid_64, height, line_n, offs, (uint32_t *)end);
} }
@ -2312,7 +2312,7 @@ void rdp_loadtile()
if (g_settings->fb_hwfbe_enabled()) if (g_settings->fb_hwfbe_enabled())
{ {
setTBufTex(rdp.tiles[tile].t_mem, rdp.tiles[tile].line*height); setTBufTex(rdp.tiles(tile).t_mem, rdp.tiles(tile).line*height);
} }
} }
@ -2323,7 +2323,7 @@ void rdp_settile()
rdp.first = 0; rdp.first = 0;
rdp.last_tile = (uint32_t)((rdp.cmd1 >> 24) & 0x07); rdp.last_tile = (uint32_t)((rdp.cmd1 >> 24) & 0x07);
TILE *tile = &rdp.tiles[rdp.last_tile]; TILE *tile = &rdp.tiles(rdp.last_tile);
tile->format = (uint8_t)((rdp.cmd0 >> 21) & 0x07); tile->format = (uint8_t)((rdp.cmd0 >> 21) & 0x07);
tile->size = (uint8_t)((rdp.cmd0 >> 19) & 0x03); tile->size = (uint8_t)((rdp.cmd0 >> 19) & 0x03);
@ -3915,23 +3915,23 @@ void lle_triangle(uint32_t w1, uint32_t w2, int shade, int texture, int zbuffer,
v->v1 = v->v0 = v->ov; v->v1 = v->v0 = v->ov;
if (rdp.tex >= 1 && rdp.cur_cache[0]) if (rdp.tex >= 1 && rdp.cur_cache[0])
{ {
if (rdp.tiles[rdp.cur_tile].shift_s) if (rdp.tiles(rdp.cur_tile).shift_s)
{ {
if (rdp.tiles[rdp.cur_tile].shift_s > 10) if (rdp.tiles(rdp.cur_tile).shift_s > 10)
v->u0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_s)); v->u0 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile).shift_s));
else else
v->u0 /= (float)(1 << rdp.tiles[rdp.cur_tile].shift_s); v->u0 /= (float)(1 << rdp.tiles(rdp.cur_tile).shift_s);
} }
if (rdp.tiles[rdp.cur_tile].shift_t) if (rdp.tiles(rdp.cur_tile).shift_t)
{ {
if (rdp.tiles[rdp.cur_tile].shift_t > 10) if (rdp.tiles(rdp.cur_tile).shift_t > 10)
v->v0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_t)); v->v0 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile).shift_t));
else else
v->v0 /= (float)(1 << rdp.tiles[rdp.cur_tile].shift_t); v->v0 /= (float)(1 << rdp.tiles(rdp.cur_tile).shift_t);
} }
v->u0 -= rdp.tiles[rdp.cur_tile].f_ul_s; v->u0 -= rdp.tiles(rdp.cur_tile).f_ul_s;
v->v0 -= rdp.tiles[rdp.cur_tile].f_ul_t; v->v0 -= rdp.tiles(rdp.cur_tile).f_ul_t;
v->u0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_x * v->u0; v->u0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_x * v->u0;
v->v0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_y * v->v0; v->v0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_y * v->v0;
v->u0 /= v->w; v->u0 /= v->w;
@ -3940,23 +3940,23 @@ void lle_triangle(uint32_t w1, uint32_t w2, int shade, int texture, int zbuffer,
if (rdp.tex >= 2 && rdp.cur_cache[1]) if (rdp.tex >= 2 && rdp.cur_cache[1])
{ {
if (rdp.tiles[rdp.cur_tile + 1].shift_s) if (rdp.tiles(rdp.cur_tile + 1).shift_s)
{ {
if (rdp.tiles[rdp.cur_tile + 1].shift_s > 10) if (rdp.tiles(rdp.cur_tile + 1).shift_s > 10)
v->u1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_s)); v->u1 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile + 1).shift_s));
else else
v->u1 /= (float)(1 << rdp.tiles[rdp.cur_tile + 1].shift_s); v->u1 /= (float)(1 << rdp.tiles(rdp.cur_tile + 1).shift_s);
} }
if (rdp.tiles[rdp.cur_tile + 1].shift_t) if (rdp.tiles(rdp.cur_tile + 1).shift_t)
{ {
if (rdp.tiles[rdp.cur_tile + 1].shift_t > 10) if (rdp.tiles(rdp.cur_tile + 1).shift_t > 10)
v->v1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_t)); v->v1 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile + 1).shift_t));
else else
v->v1 /= (float)(1 << rdp.tiles[rdp.cur_tile + 1].shift_t); v->v1 /= (float)(1 << rdp.tiles(rdp.cur_tile + 1).shift_t);
} }
v->u1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_s; v->u1 -= rdp.tiles(rdp.cur_tile + 1).f_ul_s;
v->v1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_t; v->v1 -= rdp.tiles(rdp.cur_tile + 1).f_ul_t;
v->u1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_x * v->u1; v->u1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_x * v->u1;
v->v1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_y * v->v1; v->v1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_y * v->v1;
v->u1 /= v->w; v->u1 /= v->w;

5
Source/Project64-video/rdp.h
View File

@ -359,6 +359,7 @@ public:
bool init(); bool init();
void free(); void free();
inline TILE & tiles(int index) { return m_tiles[index]; }
// Clipping // Clipping
int clip; // clipping flags int clip; // clipping flags
VERTEX *vtx1; //[256] copy vertex buffer #1 (used for clipping) VERTEX *vtx1; //[256] copy vertex buffer #1 (used for clipping)
@ -470,7 +471,9 @@ public:
// Textures // Textures
TEXTURE_IMAGE timg; // 1 for each tmem address TEXTURE_IMAGE timg; // 1 for each tmem address
TILE tiles[8]; // 8 tile descriptors private:
TILE m_tiles[8]; // 8 tile descriptors
public:
uint8_t tmem[4096]; // 4k tmem uint8_t tmem[4096]; // 4k tmem
uint32_t addr[512]; // 512 addresses (used to determine address loaded from) uint32_t addr[512]; // 512 addresses (used to determine address loaded from)
LOAD_TILE_INFO load_info[512]; // 512 addresses. inforamation about tile loading. LOAD_TILE_INFO load_info[512]; // 512 addresses. inforamation about tile loading.

10
Source/Project64-video/turbo3D.cpp
View File

@ -155,7 +155,7 @@ static void t3d_vertex(uint32_t addr, uint32_t v0, uint32_t n)
if (v->y < -v->w) v->scr_off |= 4; if (v->y < -v->w) v->scr_off |= 4;
if (v->y > v->w) v->scr_off |= 8; if (v->y > v->w) v->scr_off |= 8;
if (v->w < 0.1f) v->scr_off |= 16; if (v->w < 0.1f) v->scr_off |= 16;
WriteTrace(TraceRDP, TraceVerbose, "v%d - x: %f, y: %f, z: %f, w: %f, u: %f, v: %f, f: %f, z_w: %f, r=%d, g=%d, b=%d, a=%d", i >> 4, v->x, v->y, v->z, v->w, v->ou*rdp.tiles[rdp.cur_tile].s_scale, v->ov*rdp.tiles[rdp.cur_tile].t_scale, v->f, v->z_w, v->r, v->g, v->b, v->a); WriteTrace(TraceRDP, TraceVerbose, "v%d - x: %f, y: %f, z: %f, w: %f, u: %f, v: %f, f: %f, z_w: %f, r=%d, g=%d, b=%d, a=%d", i >> 4, v->x, v->y, v->z, v->w, v->ou*rdp.tiles(rdp.cur_tile).s_scale, v->ov*rdp.tiles(rdp.cur_tile).t_scale, v->f, v->z_w, v->r, v->g, v->b, v->a);
} }
} }
@ -165,10 +165,10 @@ static void t3dLoadObject(uint32_t pstate, uint32_t pvtx, uint32_t ptri)
t3dState *ostate = (t3dState*)&gfx.RDRAM[segoffset(pstate)]; t3dState *ostate = (t3dState*)&gfx.RDRAM[segoffset(pstate)];
rdp.cur_tile = (ostate->textureState) & 7; rdp.cur_tile = (ostate->textureState) & 7;
WriteTrace(TraceRDP, TraceDebug, "tile: %d", rdp.cur_tile); WriteTrace(TraceRDP, TraceDebug, "tile: %d", rdp.cur_tile);
if (rdp.tiles[rdp.cur_tile].s_scale < 0.001f) if (rdp.tiles(rdp.cur_tile).s_scale < 0.001f)
rdp.tiles[rdp.cur_tile].s_scale = 0.015625; rdp.tiles(rdp.cur_tile).s_scale = 0.015625;
if (rdp.tiles[rdp.cur_tile].t_scale < 0.001f) if (rdp.tiles(rdp.cur_tile).t_scale < 0.001f)
rdp.tiles[rdp.cur_tile].t_scale = 0.015625; rdp.tiles(rdp.cur_tile).t_scale = 0.015625;
WriteTrace(TraceRDP, TraceVerbose, "renderState: %08lx, textureState: %08lx, othermode0: %08lx, othermode1: %08lx, rdpCmds: %08lx, triCount : %d, v0: %d, vn: %d", ostate->renderState, ostate->textureState, WriteTrace(TraceRDP, TraceVerbose, "renderState: %08lx, textureState: %08lx, othermode0: %08lx, othermode1: %08lx, rdpCmds: %08lx, triCount : %d, v0: %d, vn: %d", ostate->renderState, ostate->textureState,
ostate->othermode0, ostate->othermode1, ostate->rdpCmds, ostate->triCount, ostate->vtxV0, ostate->vtxCount); ostate->othermode0, ostate->othermode1, ostate->rdpCmds, ostate->triCount, ostate->vtxV0, ostate->vtxCount);

6
Source/Project64-video/ucode00.cpp
View File

@ -110,7 +110,7 @@ void rsp_vertex(int v0, int n)
v->g = ((uint8_t*)gfx.RDRAM)[(addr + i + 13) ^ 3]; v->g = ((uint8_t*)gfx.RDRAM)[(addr + i + 13) ^ 3];
v->b = ((uint8_t*)gfx.RDRAM)[(addr + i + 14) ^ 3]; v->b = ((uint8_t*)gfx.RDRAM)[(addr + i + 14) ^ 3];
} }
WriteTrace(TraceRDP, TraceVerbose, "v%d - x: %f, y: %f, z: %f, w: %f, u: %f, v: %f, f: %f, z_w: %f, r=%d, g=%d, b=%d, a=%d", i >> 4, v->x, v->y, v->z, v->w, v->ou*rdp.tiles[rdp.cur_tile].s_scale, v->ov*rdp.tiles[rdp.cur_tile].t_scale, v->f, v->z_w, v->r, v->g, v->b, v->a); WriteTrace(TraceRDP, TraceVerbose, "v%d - x: %f, y: %f, z: %f, w: %f, u: %f, v: %f, f: %f, z_w: %f, r=%d, g=%d, b=%d, a=%d", i >> 4, v->x, v->y, v->z, v->w, v->ou*rdp.tiles(rdp.cur_tile).s_scale, v->ov*rdp.tiles(rdp.cur_tile).t_scale, v->f, v->z_w, v->r, v->g, v->b, v->a);
} }
} }
@ -758,7 +758,7 @@ void uc0_texture()
uint16_t s = (uint16_t)((rdp.cmd1 >> 16) & 0xFFFF); uint16_t s = (uint16_t)((rdp.cmd1 >> 16) & 0xFFFF);
uint16_t t = (uint16_t)(rdp.cmd1 & 0xFFFF); uint16_t t = (uint16_t)(rdp.cmd1 & 0xFFFF);
TILE *tmp_tile = &rdp.tiles[tile]; TILE *tmp_tile = &rdp.tiles(tile);
tmp_tile->on = 1; tmp_tile->on = 1;
tmp_tile->org_s_scale = s; tmp_tile->org_s_scale = s;
tmp_tile->org_t_scale = t; tmp_tile->org_t_scale = t;
@ -775,7 +775,7 @@ void uc0_texture()
else else
{ {
WriteTrace(TraceRDP, TraceDebug, "uc0:texture skipped b/c of off"); WriteTrace(TraceRDP, TraceDebug, "uc0:texture skipped b/c of off");
rdp.tiles[tile].on = 0; rdp.tiles(tile).on = 0;
} }
} }

2
Source/Project64-video/ucode02.cpp
View File

@ -185,7 +185,7 @@ void uc2_vertex()
v->g = ((uint8_t*)gfx.RDRAM)[(addr + i + 13) ^ 3]; v->g = ((uint8_t*)gfx.RDRAM)[(addr + i + 13) ^ 3];
v->b = ((uint8_t*)gfx.RDRAM)[(addr + i + 14) ^ 3]; v->b = ((uint8_t*)gfx.RDRAM)[(addr + i + 14) ^ 3];
} }
WriteTrace(TraceRDP, TraceVerbose, "v%d - x: %f, y: %f, z: %f, w: %f, u: %f, v: %f, f: %f, z_w: %f, r=%d, g=%d, b=%d, a=%d", i >> 4, v->x, v->y, v->z, v->w, v->ou*rdp.tiles[rdp.cur_tile].s_scale, v->ov*rdp.tiles[rdp.cur_tile].t_scale, v->f, v->z_w, v->r, v->g, v->b, v->a); WriteTrace(TraceRDP, TraceVerbose, "v%d - x: %f, y: %f, z: %f, w: %f, u: %f, v: %f, f: %f, z_w: %f, r=%d, g=%d, b=%d, a=%d", i >> 4, v->x, v->y, v->z, v->w, v->ou*rdp.tiles(rdp.cur_tile).s_scale, v->ov*rdp.tiles(rdp.cur_tile).t_scale, v->f, v->z_w, v->r, v->g, v->b, v->a);
} }
rdp.geom_mode = geom_mode; rdp.geom_mode = geom_mode;
} }

58
Source/Project64-video/ucode06.cpp
View File

@ -387,7 +387,7 @@ void DrawImage(DRAWIMAGE & d)
rdp.timg.set_by = 0; rdp.timg.set_by = 0;
// SetTile () // SetTile ()
TILE *tile = &rdp.tiles[0]; TILE *tile = &rdp.tiles(0);
tile->format = d.imageFmt; // RGBA tile->format = d.imageFmt; // RGBA
tile->size = d.imageSiz; // 16-bit tile->size = d.imageSiz; // 16-bit
tile->line = line; tile->line = line;
@ -402,10 +402,10 @@ void DrawImage(DRAWIMAGE & d)
tile->mask_s = 0; tile->mask_s = 0;
tile->shift_s = 0; tile->shift_s = 0;
rdp.tiles[0].ul_s = 0; rdp.tiles(0).ul_s = 0;
rdp.tiles[0].ul_t = 0; rdp.tiles(0).ul_t = 0;
rdp.tiles[0].lr_s = x_size - 1; rdp.tiles(0).lr_s = x_size - 1;
rdp.tiles[0].lr_t = y_size - 1; rdp.tiles(0).lr_t = y_size - 1;
const float Z = set_sprite_combine_mode(); const float Z = set_sprite_combine_mode();
if (rdp.cycle_mode == 2) if (rdp.cycle_mode == 2)
@ -472,14 +472,14 @@ void DrawImage(DRAWIMAGE & d)
// ** Load the texture, constant portions have been set above // ** Load the texture, constant portions have been set above
// SetTileSize () // SetTileSize ()
rdp.tiles[0].ul_s = tb_u; rdp.tiles(0).ul_s = tb_u;
rdp.tiles[0].ul_t = tb_v; rdp.tiles(0).ul_t = tb_v;
rdp.tiles[0].lr_s = tb_u + x_size - 1; rdp.tiles(0).lr_s = tb_u + x_size - 1;
rdp.tiles[0].lr_t = tb_v + y_size - 1; rdp.tiles(0).lr_t = tb_v + y_size - 1;
// LoadTile () // LoadTile ()
rdp.cmd0 = ((int)rdp.tiles[0].ul_s << 14) | ((int)rdp.tiles[0].ul_t << 2); rdp.cmd0 = ((int)rdp.tiles(0).ul_s << 14) | ((int)rdp.tiles(0).ul_t << 2);
rdp.cmd1 = ((int)rdp.tiles[0].lr_s << 14) | ((int)rdp.tiles[0].lr_t << 2); rdp.cmd1 = ((int)rdp.tiles(0).lr_s << 14) | ((int)rdp.tiles(0).lr_t << 2);
rdp_loadtile(); rdp_loadtile();
TexCache(); TexCache();
@ -956,7 +956,7 @@ static void uc6_read_object_data(DRAWOBJECT & d)
static void uc6_init_tile(const DRAWOBJECT & d) static void uc6_init_tile(const DRAWOBJECT & d)
{ {
// SetTile () // SetTile ()
TILE *tile = &rdp.tiles[0]; TILE *tile = &rdp.tiles(0);
tile->format = d.imageFmt; // RGBA tile->format = d.imageFmt; // RGBA
tile->size = d.imageSiz; // 16-bit tile->size = d.imageSiz; // 16-bit
tile->line = d.imageStride; tile->line = d.imageStride;
@ -972,10 +972,10 @@ static void uc6_init_tile(const DRAWOBJECT & d)
tile->shift_s = 0; tile->shift_s = 0;
// SetTileSize () // SetTileSize ()
rdp.tiles[0].ul_s = 0; rdp.tiles(0).ul_s = 0;
rdp.tiles[0].ul_t = 0; rdp.tiles(0).ul_t = 0;
rdp.tiles[0].lr_s = (d.imageW > 0) ? d.imageW - 1 : 0; rdp.tiles(0).lr_s = (d.imageW > 0) ? d.imageW - 1 : 0;
rdp.tiles[0].lr_t = (d.imageH > 0) ? d.imageH - 1 : 0; rdp.tiles(0).lr_t = (d.imageH > 0) ? d.imageH - 1 : 0;
} }
void uc6_obj_rectangle() void uc6_obj_rectangle()
@ -1307,8 +1307,8 @@ void uc6_obj_loadtxtr()
rdp.timg.width = 1; rdp.timg.width = 1;
rdp.timg.size = 1; rdp.timg.size = 1;
rdp.tiles[7].t_mem = tmem; rdp.tiles(7).t_mem = tmem;
rdp.tiles[7].size = 1; rdp.tiles(7).size = 1;
rdp.cmd0 = 0; rdp.cmd0 = 0;
rdp.cmd1 = 0x07000000 | (tsize << 14) | tline; rdp.cmd1 = 0x07000000 | (tsize << 14) | tline;
rdp_loadblock(); rdp_loadblock();
@ -1328,9 +1328,9 @@ void uc6_obj_loadtxtr()
rdp.timg.width = line << 3; rdp.timg.width = line << 3;
rdp.timg.size = 1; rdp.timg.size = 1;
rdp.tiles[7].t_mem = tmem; rdp.tiles(7).t_mem = tmem;
rdp.tiles[7].line = line; rdp.tiles(7).line = line;
rdp.tiles[7].size = 1; rdp.tiles(7).size = 1;
rdp.cmd0 = 0; rdp.cmd0 = 0;
rdp.cmd1 = 0x07000000 | (twidth << 14) | (theight << 2); rdp.cmd1 = 0x07000000 | (twidth << 14) | (theight << 2);
@ -1507,15 +1507,15 @@ void uc6_sprite2d()
rdp.timg.addr = d.imagePtr; rdp.timg.addr = d.imagePtr;
rdp.timg.width = stride; rdp.timg.width = stride;
rdp.tiles[7].t_mem = 0; rdp.tiles(7).t_mem = 0;
rdp.tiles[7].line = line;//(d.imageW>>3); rdp.tiles(7).line = line;//(d.imageW>>3);
rdp.tiles[7].size = d.imageSiz; rdp.tiles(7).size = d.imageSiz;
rdp.cmd0 = (d.imageX << 14) | (d.imageY << 2); rdp.cmd0 = (d.imageX << 14) | (d.imageY << 2);
rdp.cmd1 = 0x07000000 | ((d.imageX + d.imageW - 1) << 14) | ((d.imageY + d.imageH - 1) << 2); rdp.cmd1 = 0x07000000 | ((d.imageX + d.imageW - 1) << 14) | ((d.imageY + d.imageH - 1) << 2);
rdp_loadtile(); rdp_loadtile();
// SetTile () // SetTile ()
TILE *tile = &rdp.tiles[0]; TILE *tile = &rdp.tiles(0);
tile->format = d.imageFmt; tile->format = d.imageFmt;
tile->size = d.imageSiz; tile->size = d.imageSiz;
tile->line = line;//(d.imageW>>3); tile->line = line;//(d.imageW>>3);
@ -1531,10 +1531,10 @@ void uc6_sprite2d()
tile->shift_s = 0; tile->shift_s = 0;
// SetTileSize () // SetTileSize ()
rdp.tiles[0].ul_s = d.imageX; rdp.tiles(0).ul_s = d.imageX;
rdp.tiles[0].ul_t = d.imageY; rdp.tiles(0).ul_t = d.imageY;
rdp.tiles[0].lr_s = d.imageX + d.imageW - 1; rdp.tiles(0).lr_s = d.imageX + d.imageW - 1;
rdp.tiles[0].lr_t = d.imageY + d.imageH - 1; rdp.tiles(0).lr_t = d.imageY + d.imageH - 1;
float Z = set_sprite_combine_mode(); float Z = set_sprite_combine_mode();

6
Source/Project64-video/ucode09.cpp
View File

@ -132,7 +132,7 @@ static void uc9_draw_object(uint8_t * addr, uint32_t type)
v.ov = ((short*)addr)[5 ^ 1]; v.ov = ((short*)addr)[5 ^ 1];
v.w = Calc_invw(((int*)addr)[3]) / 31.0f; v.w = Calc_invw(((int*)addr)[3]) / 31.0f;
v.oow = 1.0f / v.w; v.oow = 1.0f / v.w;
WriteTrace(TraceRDP, TraceDebug, "v%d - sx: %f, sy: %f ou: %f, ov: %f, w: %f, r=%d, g=%d, b=%d, a=%d", i, v.sx / rdp.scale_x, v.sy / rdp.scale_y, v.ou*rdp.tiles[rdp.cur_tile].s_scale, v.ov*rdp.tiles[rdp.cur_tile].t_scale, v.w, v.r, v.g, v.b, v.a); WriteTrace(TraceRDP, TraceDebug, "v%d - sx: %f, sy: %f ou: %f, ov: %f, w: %f, r=%d, g=%d, b=%d, a=%d", i, v.sx / rdp.scale_x, v.sy / rdp.scale_y, v.ou*rdp.tiles(rdp.cur_tile).s_scale, v.ov*rdp.tiles(rdp.cur_tile).t_scale, v.w, v.r, v.g, v.b, v.a);
} }
else else
{ {
@ -625,7 +625,7 @@ void uc9_movemem()
rdp.mipmap_level = 0; rdp.mipmap_level = 0;
rdp.cur_tile = 0; rdp.cur_tile = 0;
TILE *tmp_tile = &rdp.tiles[0]; TILE *tmp_tile = &rdp.tiles(0);
tmp_tile->on = 1; tmp_tile->on = 1;
tmp_tile->org_s_scale = 0xFFFF; tmp_tile->org_s_scale = 0xFFFF;
tmp_tile->org_t_scale = 0xFFFF; tmp_tile->org_t_scale = 0xFFFF;
@ -667,7 +667,7 @@ void uc9_setscissor()
rdp.mipmap_level = 0; rdp.mipmap_level = 0;
rdp.cur_tile = 0; rdp.cur_tile = 0;
TILE *tmp_tile = &rdp.tiles[0]; TILE *tmp_tile = &rdp.tiles(0);
tmp_tile->on = 1; tmp_tile->on = 1;
tmp_tile->org_s_scale = 0xFFFF; tmp_tile->org_s_scale = 0xFFFF;
tmp_tile->org_t_scale = 0xFFFF; tmp_tile->org_t_scale = 0xFFFF;