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])
{
// scale >> 6 is size to map to
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->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->uv_scaled = 1;
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;
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);
t_scale = minval(rdp.tiles[rdp.cur_tile].org_t_scale >> 6, rdp.tiles[rdp.cur_tile].lr_t);
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);
}
else
{
s_scale = rdp.tiles[rdp.cur_tile].org_s_scale >> 6;
t_scale = rdp.tiles[rdp.cur_tile].org_t_scale >> 6;
s_scale = rdp.tiles(rdp.cur_tile).org_s_scale >> 6;
t_scale = rdp.tiles(rdp.cur_tile).org_t_scale >> 6;
}
TransformVector(v->vec, vec, rdp.model);
// 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)
/* [row][col]*/
typedef float v4sf __attribute__ ((vector_size (16)));
typedef float v4sf __attribute__((vector_size(16)));
v4sf row0 = _mm_loadu_ps(m2[0]);
v4sf row1 = _mm_loadu_ps(m2[1]);
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]
v4sf tmp = leftrow;
tmp = _mm_shuffle_ps (tmp, tmp, 0);
tmp = _mm_shuffle_ps(tmp, tmp, 0);
// Calculate the four first summands
v4sf destrow = tmp * row0;
// Fill tmp with four copies of leftrow[1]
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;
// Fill tmp with four copies of leftrow[2]
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;
// Fill tmp with four copies of leftrow[3]
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;
__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
{
mov eax, dword ptr[r]
mov ecx, dword ptr[m1]
mov edx, dword ptr[m2]
mov ecx, dword ptr[m1]
mov edx, dword ptr[m2]
movaps xmm0, [edx]
movaps xmm1, [edx + 16]
movaps xmm2, [edx + 32]
movaps xmm3, [edx + 48]
movaps xmm0, [edx]
movaps xmm1, [edx + 16]
movaps xmm2, [edx + 32]
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 xmm5, xmm4
movaps xmm6, xmm4
movaps xmm7, xmm4
movaps xmm4, xmmword ptr[ecx]
movaps xmm5, xmm4
movaps xmm6, xmm4
movaps xmm7, xmm4
shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b
shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b
mulps xmm4, xmm0
mulps xmm5, xmm1
mulps xmm6, xmm2
mulps xmm7, xmm3
mulps xmm4, xmm0
mulps xmm5, xmm1
mulps xmm6, xmm2
mulps xmm7, xmm3
addps xmm4, xmm5
addps xmm4, xmm6
addps xmm4, xmm7
addps xmm4, xmm5
addps xmm4, xmm6
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 xmm5, xmm4
movaps xmm6, xmm4
movaps xmm7, xmm4
movaps xmm4, xmmword ptr[ecx + 16]
movaps xmm5, xmm4
movaps xmm6, xmm4
movaps xmm7, xmm4
shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b
shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b
mulps xmm4, xmm0
mulps xmm5, xmm1
mulps xmm6, xmm2
mulps xmm7, xmm3
mulps xmm4, xmm0
mulps xmm5, xmm1
mulps xmm6, xmm2
mulps xmm7, xmm3
addps xmm4, xmm5
addps xmm4, xmm6
addps xmm4, xmm7
addps xmm4, xmm5
addps xmm4, xmm6
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 xmm5, xmm4
movaps xmm6, xmm4
movaps xmm7, xmm4
movaps xmm4, xmmword ptr[ecx + 32]
movaps xmm5, xmm4
movaps xmm6, xmm4
movaps xmm7, xmm4
shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b
shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b
mulps xmm4, xmm0
mulps xmm5, xmm1
mulps xmm6, xmm2
mulps xmm7, xmm3
mulps xmm4, xmm0
mulps xmm5, xmm1
mulps xmm6, xmm2
mulps xmm7, xmm3
addps xmm4, xmm5
addps xmm4, xmm6
addps xmm4, xmm7
addps xmm4, xmm5
addps xmm4, xmm6
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 xmm5, xmm4
movaps xmm6, xmm4
movaps xmm7, xmm4
movaps xmm4, xmmword ptr[ecx + 48]
movaps xmm5, xmm4
movaps xmm6, xmm4
movaps xmm7, xmm4
shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b
shufps xmm4, xmm4, 00000000b
shufps xmm5, xmm5, 01010101b
shufps xmm6, xmm6, 10101010b
shufps xmm7, xmm7, 11111111b
mulps xmm4, xmm0
mulps xmm5, xmm1
mulps xmm6, xmm2
mulps xmm7, xmm3
mulps xmm4, xmm0
mulps xmm5, xmm1
mulps xmm6, xmm2
mulps xmm7, xmm3
addps xmm4, xmm5
addps xmm4, xmm6
addps xmm4, xmm7
addps xmm4, xmm5
addps xmm4, xmm6
addps xmm4, xmm7
movaps xmmword ptr[eax + 48], xmm4
movaps xmmword ptr[eax + 48], xmm4
}
#endif // _WIN32
}
@ -383,9 +383,9 @@ void math_init()
}
GLIDE64_CATCH
{ return; }
// Check for SSE
if (edx & (1 << 25))
IsSSE = TRUE;
// Check for SSE
if (edx & (1 << 25))
IsSSE = TRUE;
#elif !defined(NO_ASM) && !defined(NOSSE)
DWORD dwEdx;
__try
@ -393,8 +393,8 @@ void math_init()
__asm
{
mov eax, 1
cpuid
mov dwEdx, edx
cpuid
mov dwEdx, edx
}
}
__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
{
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,
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);
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,
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();
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,
GR_CMBX_LOCAL_TEXTURE_RGB, GR_FUNC_MODE_ZERO,
@ -8769,7 +8769,7 @@ static void ac_t1()
GR_COMBINE_FACTOR_ONE,
GR_COMBINE_LOCAL_NONE,
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();
else
A_USE_T1();
@ -10038,7 +10038,7 @@ static void ac__t0_mul_t1__mul_prim()
GR_COMBINE_LOCAL_CONSTANT,
GR_COMBINE_OTHER_TEXTURE);
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();
}

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

@ -170,11 +170,11 @@ void GetTexInfo(int id, int tile)
int wid_64, line, bpl;
// Get width and height
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_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;
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_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);
if (g_settings->alt_tex_size())
{
@ -183,32 +183,32 @@ void GetTexInfo(int id, int tile)
// textures.
// 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
width = minval(mask_width, tile_width);
// actual width
rdp.tiles[tile].width = tile_width;
rdp.tiles(tile).width = tile_width;
}
else
{
// wrap all the way
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
height = minval(mask_height, tile_height);
// actual height
rdp.tiles[tile].height = tile_height;
rdp.tiles(tile).height = tile_height;
}
else
{
// wrap all the way
height = minval(mask_height, tile_height);
rdp.tiles[tile].height = height;
rdp.tiles(tile).height = height;
}
}
else
@ -224,52 +224,52 @@ void GetTexInfo(int id, int tile)
}
// 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
width = minval(mask_width, tile_width);
// actual width
rdp.tiles[tile].width = tile_width;
rdp.tiles(tile).width = tile_width;
}
else
{
// wrap all the way
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
height = minval(mask_height, tile_height);
// actual height
rdp.tiles[tile].height = tile_height;
rdp.tiles(tile).height = tile_height;
}
else
{
// wrap all the way
height = mask_height;
rdp.tiles[tile].height = mask_height;
rdp.tiles(tile).height = mask_height;
}
}
// without any large texture fixing-up; for alignment
int real_image_width = rdp.tiles[tile].width;
int real_image_height = rdp.tiles[tile].height;
int real_image_width = rdp.tiles(tile).width;
int real_image_height = rdp.tiles(tile).height;
int crc_height = height;
if (rdp.timg.set_by == 1)
crc_height = tile_height;
bpl = width << rdp.tiles[tile].size >> 1;
bpl = width << rdp.tiles(tile).size >> 1;
// ** COMMENT THIS TO DISABLE LARGE TEXTURES
#ifdef LARGE_TEXTURE_HANDLING
if (!voodoo.sup_large_tex && width > 256)
{
info->splits = ((width - 1) >> 8) + 1;
info->splitheight = rdp.tiles[tile].height;
rdp.tiles[tile].height *= info->splits;
rdp.tiles[tile].width = 256;
info->splitheight = rdp.tiles(tile).height;
rdp.tiles(tile).height *= info->splits;
rdp.tiles(tile).width = 256;
width = 256;
}
else
@ -280,19 +280,19 @@ void GetTexInfo(int id, int tile)
}
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 height: %d", height);
WriteTrace(TraceRDP, TraceDebug, " | | | |- actual width: %d", rdp.tiles[tile].width);
WriteTrace(TraceRDP, TraceDebug, " | | | |- actual height: %d", rdp.tiles[tile].height);
WriteTrace(TraceRDP, TraceDebug, " | | | |- size: %d", rdp.tiles[tile].size);
WriteTrace(TraceRDP, TraceDebug, " | | | +- format: %d", rdp.tiles[tile].format);
WriteTrace(TraceRDP, TraceDebug, " | | | |- actual width: %d", rdp.tiles(tile).width);
WriteTrace(TraceRDP, TraceDebug, " | | | |- actual height: %d", rdp.tiles(tile).height);
WriteTrace(TraceRDP, TraceDebug, " | | | |- size: %d", rdp.tiles(tile).size);
WriteTrace(TraceRDP, TraceDebug, " | | | +- format: %d", rdp.tiles(tile).format);
WriteTrace(TraceRDP, TraceDebug, " | | |- Calculating CRC... ");
// ** CRC CHECK
wid_64 = width << (rdp.tiles[tile].size) >> 1;
if (rdp.tiles[tile].size == 3)
wid_64 = width << (rdp.tiles(tile).size) >> 1;
if (rdp.tiles(tile).size == 3)
{
if (wid_64 & 15) wid_64 += 16;
wid_64 &= 0xFFFFFFF0;
@ -304,20 +304,20 @@ void GetTexInfo(int id, int tile)
wid_64 = wid_64 >> 3;
// 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!!! ");
// 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].lr_t = rdp.tiles[tile].ul_t + y - 1;
rdp.tiles(tile).clamp_t = 0;
rdp.tiles(tile).lr_t = rdp.tiles(tile).ul_t + y - 1;
// calc mask
int shift;
for (shift = 0; (1 << shift) < y; shift++);
rdp.tiles[tile].mask_t = shift;
rdp.tiles(tile).mask_t = shift;
// restart the function
WriteTrace(TraceRDP, TraceDebug, "restarting...");
@ -325,18 +325,18 @@ void GetTexInfo(int id, int tile)
return;
}
line = rdp.tiles[tile].line;
if (rdp.tiles[tile].size == 3)
line = rdp.tiles(tile).line;
if (rdp.tiles(tile).size == 3)
line <<= 1;
uint32_t crc = 0;
if (g_settings->fast_crc())
{
line = (line - wid_64) << 3;
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 (rdp.tiles[tile].size < 3)
if (rdp.tiles(tile).size < 3)
crc = textureCRC(addr, wid_64, crc_height, line);
else //32b texture
{
@ -350,9 +350,9 @@ void GetTexInfo(int id, int tile)
else
{
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);
if (rdp.tiles[tile].size < 3)
if (rdp.tiles(tile).size < 3)
{
line2 <<= 3;
for (int y = 0; y < crc_height; y++)
@ -377,19 +377,19 @@ void GetTexInfo(int id, int tile)
line = (line - wid_64) << 3;
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)
crc += rdp.pal_8_crc[rdp.tiles[tile].palette];
if (rdp.tiles(tile).size == 0)
crc += rdp.pal_8_crc[rdp.tiles(tile).palette];
else
crc += rdp.pal_256_crc;
}
WriteTrace(TraceRDP, TraceDebug, "Done. CRC is: %08lx.", crc);
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].mirror_t << 16) | (rdp.tiles[tile].mask_t << 12);
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).mirror_t << 16) | (rdp.tiles(tile).mask_t << 12);
info->real_image_width = real_image_width;
info->real_image_height = real_image_height;
@ -431,18 +431,18 @@ void GetTexInfo(int id, int tile)
}
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)
{
if (node->crc == crc)
{
cache = (CACHE_LUT*)node->data;
if (/*tex_found[id][node->tmu] == -1 &&
rdp.tiles[tile].palette == cache->palette &&
rdp.tiles[tile].format == cache->format &&
rdp.tiles[tile].size == cache->size &&*/
rdp.tiles[tile].width == cache->width &&
rdp.tiles[tile].height == cache->height &&
rdp.tiles(tile).palette == cache->palette &&
rdp.tiles(tile).format == cache->format &&
rdp.tiles(tile).size == cache->size &&*/
rdp.tiles(tile).width == cache->width &&
rdp.tiles(tile).height == cache->height &&
flags == cache->flags)
{
if (!(mod + cache->mod) || (cache->mod == mod &&
@ -862,15 +862,15 @@ void TexCache()
int clamp_s, clamp_t;
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_t = rdp.tiles[tile].clamp_t && rdp.tiles[tile].lr_t - rdp.tiles[tile].ul_t < 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;
}
else
{
clamp_s = (rdp.tiles[tile].clamp_s || rdp.tiles[tile].mask_s == 0) &&
rdp.tiles[tile].lr_s - rdp.tiles[tile].ul_s < 256;
clamp_t = (rdp.tiles[tile].clamp_t || rdp.tiles[tile].mask_t == 0) &&
rdp.tiles[tile].lr_t - rdp.tiles[tile].ul_t < 256;
clamp_s = (rdp.tiles(tile).clamp_s || rdp.tiles(tile).mask_s == 0) &&
rdp.tiles(tile).lr_s - rdp.tiles(tile).ul_s < 256;
clamp_t = (rdp.tiles(tile).clamp_t || rdp.tiles(tile).mask_t == 0) &&
rdp.tiles(tile).lr_t - rdp.tiles(tile).ul_t < 256;
}
if (rdp.cur_cache[i]->f_mirror_s)
@ -881,7 +881,7 @@ void TexCache()
mode_s = GR_TEXTURECLAMP_CLAMP;
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;
else
mode_s = GR_TEXTURECLAMP_WRAP;
@ -895,7 +895,7 @@ void TexCache()
mode_t = GR_TEXTURECLAMP_CLAMP;
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;
else
mode_t = GR_TEXTURECLAMP_WRAP;
@ -978,21 +978,21 @@ void LoadTex(int id, int tmu)
//!Hackalert
//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].size = 1;
rdp.tiles(td).format = 2;
rdp.tiles(td).size = 1;
}
// Set the data
cache->line = rdp.tiles[td].line;
cache->addr = rdp.addr[rdp.tiles[td].t_mem];
cache->line = rdp.tiles(td).line;
cache->addr = rdp.addr[rdp.tiles(td).t_mem];
cache->crc = texinfo[id].crc;
cache->palette = rdp.tiles[td].palette;
cache->width = rdp.tiles[td].width;
cache->height = rdp.tiles[td].height;
cache->format = rdp.tiles[td].format;
cache->size = rdp.tiles[td].size;
cache->palette = rdp.tiles(td).palette;
cache->width = rdp.tiles(td).width;
cache->height = rdp.tiles(td).height;
cache->format = rdp.tiles(td).format;
cache->size = rdp.tiles(td).size;
cache->tmem_addr = voodoo.tmem_ptr[tmu];
cache->set_by = rdp.timg.set_by;
cache->texrecting = rdp.texrecting;
@ -1013,8 +1013,8 @@ void LoadTex(int id, int tmu)
cache->t_info.format = GFX_TEXFMT_ARGB_1555;
// Calculate lod and aspect
uint32_t size_x = rdp.tiles[td].width;
uint32_t size_y = rdp.tiles[td].height;
uint32_t size_x = rdp.tiles(td).width;
uint32_t size_y = rdp.tiles(td).height;
// make size_x and size_y both powers of two
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.
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;
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;
}
@ -1236,50 +1236,50 @@ void LoadTex(int id, int tmu)
if (g_ghq_use)
{
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_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)
{
bpl = info.tex_width << info.tex_size >> 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);
if (info.tex_size > rdp.tiles[td].size)
tile_width <<= info.tex_size - rdp.tiles[td].size;
if (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)
tile_height = rdp.bg_image_height - rdp.tiles[td].ul_t;
if (rdp.tiles(td).lr_t > rdp.bg_image_height)
tile_height = rdp.bg_image_height - rdp.tiles(td).ul_t;
else
tile_height = info.tile_height;
}
else
{
if (rdp.tiles[td].size == 3)
bpl = rdp.tiles[td].line << 4;
if (rdp.tiles(td).size == 3)
bpl = rdp.tiles(td).line << 4;
else if (info.dxt == 0)
bpl = rdp.tiles[td].line << 3;
bpl = rdp.tiles(td).line << 3;
else {
uint32_t dxt = info.dxt;
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;
}
}
// 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;
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);
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
paladdr = (uint8_t*)(rdp.pal_8_rice + (rdp.tiles[td].palette << 4));
palette = (rdp.pal_8 + (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));
}
// 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_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);
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));
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));
if (ext_ghq_hirestex((uint64)g64_crc, cache->ricecrc, palette, &ghqTexInfo))
{
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
int start_src = i * 256; // start 256 more to the right
start_src = start_src << (rdp.tiles[td].size) >> 1;
if (rdp.tiles[td].size == 3)
start_src = start_src << (rdp.tiles(td).size) >> 1;
if (rdp.tiles(td).size == 3)
start_src >>= 1;
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,
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,
texinfo[id].wid_64, texinfo[id].height, texinfo[id].line, real_x, td);
uint32_t size = HIWORD(result);
@ -1337,19 +1337,19 @@ void LoadTex(int id, int tmu)
// ** end texture splitting **
else
{
result = load_table[rdp.tiles[td].size][rdp.tiles[td].format]
(uintptr_t(texture), uintptr_t(rdp.tmem) + (rdp.tiles[td].t_mem << 3),
result = load_table[rdp.tiles(td).size][rdp.tiles(td).format]
(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);
uint32_t size = HIWORD(result);
int min_x, min_y;
if (rdp.tiles[td].mask_s != 0)
min_x = minval((int)real_x, 1 << rdp.tiles[td].mask_s);
if (rdp.tiles(td).mask_s != 0)
min_x = minval((int)real_x, 1 << rdp.tiles(td).mask_s);
else
min_x = real_x;
if (rdp.tiles[td].mask_t != 0)
min_y = minval((int)real_y, 1 << rdp.tiles[td].mask_t);
if (rdp.tiles(td).mask_t != 0)
min_y = minval((int)real_y, 1 << rdp.tiles(td).mask_t);
else
min_y = real_y;
@ -1366,28 +1366,28 @@ void LoadTex(int id, int tmu)
if (texinfo[id].width < (int)real_x)
{
if (rdp.tiles[td].mirror_s)
if (rdp.tiles(td).mirror_s)
{
if (size == 1)
Mirror16bS((texture), rdp.tiles[td].mask_s,
Mirror16bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height);
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);
else
Mirror32bS((texture), rdp.tiles[td].mask_s,
Mirror32bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height);
}
else
{
if (size == 1)
Wrap16bS((texture), rdp.tiles[td].mask_s,
Wrap16bS((texture), rdp.tiles(td).mask_s,
real_x, real_x, texinfo[id].height);
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);
else
Wrap32bS((texture), rdp.tiles[td].mask_s,
Wrap32bS((texture), rdp.tiles(td).mask_s,
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 (rdp.tiles[td].mirror_t)
if (rdp.tiles(td).mirror_t)
{
if (size == 1)
Mirror16bT((texture), rdp.tiles[td].mask_t,
Mirror16bT((texture), rdp.tiles(td).mask_t,
real_y, real_x);
else if (size != 2)
Mirror8bT((texture), rdp.tiles[td].mask_t,
Mirror8bT((texture), rdp.tiles(td).mask_t,
real_y, real_x);
else
Mirror32bT((texture), rdp.tiles[td].mask_t,
Mirror32bT((texture), rdp.tiles(td).mask_t,
real_y, real_x);
}
else
{
if (size == 1)
Wrap16bT((texture), rdp.tiles[td].mask_t,
Wrap16bT((texture), rdp.tiles(td).mask_t,
real_y, real_x);
else if (size != 2)
Wrap8bT((texture), rdp.tiles[td].mask_t,
Wrap8bT((texture), rdp.tiles(td).mask_t,
real_y, real_x);
else
Wrap32bT((texture), rdp.tiles[td].mask_t,
Wrap32bT((texture), rdp.tiles(td).mask_t,
real_y, real_x);
}
}
@ -1597,9 +1597,9 @@ void LoadTex(int id, int tmu)
}
else
{
int tile_width = rdp.tiles[td].width;
int tile_width = rdp.tiles(td).width;
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);
cache->c_scl_x *= mult;
cache->c_scl_y *= mult;
@ -1637,11 +1637,11 @@ void LoadTex(int id, int tmu)
}
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;
else if (texinfo[id].tile_width >= 2 * texinfo[id].width)
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;
else if (texinfo[id].tile_height >= 2 * texinfo[id].height)
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 * 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 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)
{
const uint32_t line = rdp.tiles[tile].line << 2;
const uint32_t tbase = rdp.tiles[tile].t_mem << 2;
const uint32_t line = rdp.tiles(tile).line << 2;
const uint32_t tbase = rdp.tiles(tile).t_mem << 2;
const uint32_t addr = rdp.timg.addr >> 2;
const uint32_t* src = (const uint32_t*)gfx.RDRAM;
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)
{
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 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;
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;
}
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)
{
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
if (!v->uv_scaled)
{
v->ou *= rdp.tiles[rdp.cur_tile].s_scale;
v->ov *= rdp.tiles[rdp.cur_tile].t_scale;
v->ou *= rdp.tiles(rdp.cur_tile).s_scale;
v->ov *= rdp.tiles(rdp.cur_tile).t_scale;
v->uv_scaled = 1;
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;
}
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)
v->u0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_s));
if (rdp.tiles(rdp.cur_tile).shift_s > 10)
v->u0 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile).shift_s));
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)
v->v0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_t));
if (rdp.tiles(rdp.cur_tile).shift_t > 10)
v->v0 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile).shift_t));
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]->tile_uls != (int)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))
v->v0 -= rdp.tiles[rdp.cur_tile].f_ul_t; //required for megaman (boss special attack)
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;
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->u0 *= rdp.aTBuffTex[0]->u_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);
}
else
{
v->u0 -= rdp.tiles[rdp.cur_tile].f_ul_s;
v->v0 -= rdp.tiles[rdp.cur_tile].f_ul_t;
v->u0 -= rdp.tiles(rdp.cur_tile).f_ul_s;
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->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->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)
v->u1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_s));
if (rdp.tiles(rdp.cur_tile + 1).shift_s > 10)
v->u1 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile + 1).shift_s));
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)
v->v1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_t));
if (rdp.tiles(rdp.cur_tile + 1).shift_t > 10)
v->v1 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile + 1).shift_t));
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]->tile_uls != (int)rdp.tiles[rdp.cur_tile].f_ul_s)
v->u1 -= 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.aTBuffTex[1]->u_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);
}
else
{
v->u1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_s;
v->v1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_t;
v->u1 -= rdp.tiles(rdp.cur_tile + 1).f_ul_s;
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->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;
double deltaTexels, deltaPixels, lodFactor = 0;
double intptr;
float s_scale = rdp.tiles[rdp.cur_tile].width / 255.0f;
float t_scale = rdp.tiles[rdp.cur_tile].height / 255.0f;
float s_scale = rdp.tiles(rdp.cur_tile).width / 255.0f;
float t_scale = rdp.tiles(rdp.cur_tile).height / 255.0f;
if (g_settings->lodmode() == CSettings::LOD_Fast)
{
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;
memset(&timg, 0, sizeof(timg));
memset(tiles, 0, sizeof(tiles));
memset(m_tiles, 0, sizeof(m_tiles));
memset(tmem, 0, sizeof(tmem));
memset(addr, 0, sizeof(addr));
memset(load_info, 0, sizeof(load_info));
@ -864,7 +864,7 @@ EXPORT void CALL ProcessDList(void)
if (g_settings->ucode() == CSettings::ucode_Turbo3d)
{
Turbo3D();
}
}
else
{
// MAIN PROCESSING LOOP
@ -946,7 +946,7 @@ EXPORT void CALL ProcessDList(void)
CI_SET = FALSE;
}
WriteTrace(TraceRDP, TraceDebug, "ProcessDList end");
}
}
// undef - undefined instruction, always ignore
void undef()
@ -992,8 +992,8 @@ void ys_memrect()
WriteTrace(TraceRDP, TraceDebug, " off_y: %d", off_y);
uint32_t y, width = lr_x - ul_x;
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;
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 * fbaddr = gfx.RDRAM + rdp.cimg + ul_x;
for (y = ul_y; y < lr_y; y++) {
@ -1326,7 +1326,7 @@ void rdp_texrect()
{
float sx = 1, sy = 1;
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
if (tile.shift_s)
{
@ -1752,7 +1752,7 @@ void load_palette(uint32_t addr, uint16_t start, uint16_t count)
void rdp_loadtlut()
{
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 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;
rdp.last_tile_size = tile;
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_s = (float)((rdp.cmd0 >> 12) & 0xFFF) / 4.0f;
rdp.tiles(tile).f_ul_t = (float)(rdp.cmd0 & 0xFFF) / 4.0f;
int ul_s = (rdp.cmd0 >> 14) & 0x03ff;
int ul_t = (rdp.cmd0 >> 2) & 0x03ff;
@ -1816,32 +1816,32 @@ void rdp_settilesize()
if (tile_set)
{
// coords in 10.2 format
rdp.tiles[tile].ul_s = ul_s;
rdp.tiles[tile].ul_t = ul_t;
rdp.tiles[tile].lr_s = lr_s;
rdp.tiles[tile].lr_t = lr_t;
rdp.tiles(tile).ul_s = ul_s;
rdp.tiles(tile).ul_t = ul_t;
rdp.tiles(tile).lr_s = lr_s;
rdp.tiles(tile).lr_t = lr_t;
tile_set = 0;
}
}
else
{
// coords in 10.2 format
rdp.tiles[tile].ul_s = ul_s;
rdp.tiles[tile].ul_t = ul_t;
rdp.tiles[tile].lr_s = lr_s;
rdp.tiles[tile].lr_t = lr_t;
rdp.tiles(tile).ul_s = ul_s;
rdp.tiles(tile).ul_t = ul_t;
rdp.tiles(tile).lr_s = lr_s;
rdp.tiles(tile).lr_t = lr_t;
}
// handle wrapping
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_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;
rdp.update |= UPDATE_TEXTURE;
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",
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)
@ -2019,7 +2019,7 @@ void rdp_loadblock()
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
/* 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_t = (uint16_t)((rdp.cmd0 >> 2) & 0x3FF);
rdp.tiles[tile].ul_s = ul_s;
rdp.tiles[tile].ul_t = ul_t;
rdp.tiles[tile].lr_s = lr_s;
rdp.tiles(tile).ul_s = ul_s;
rdp.tiles(tile).ul_t = ul_t;
rdp.tiles(tile).lr_s = lr_s;
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.dxt = dxt;
@ -2058,14 +2058,14 @@ void rdp_loadblock()
//angrylion's advice to use ul_s in texture image offset and cnt calculations.
//Helps to fix Vigilante 8 jpeg backgrounds and logos
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);
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);
uint32_t cnt = lr_s - ul_s + 1;
if (rdp.tiles[tile].size == 3)
if (rdp.tiles(tile).size == 3)
cnt <<= 1;
if (((rdp.tiles[tile].t_mem + cnt) << 3) > sizeof(rdp.tmem)) {
cnt = (sizeof(rdp.tmem) >> 3) - (rdp.tiles[tile].t_mem);
if (((rdp.tiles(tile).t_mem + cnt) << 3) > sizeof(rdp.tmem)) {
cnt = (sizeof(rdp.tmem) >> 3) - (rdp.tiles(tile).t_mem);
}
if (rdp.timg.size == 3)
@ -2074,7 +2074,7 @@ void rdp_loadblock()
loadBlock((uint32_t *)gfx.RDRAM, (uint32_t *)dst, off, _dxt, cnt);
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;
@ -2084,7 +2084,7 @@ void rdp_loadblock()
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);
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_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
{
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)
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)
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].mask_s = rdp.tiles[wrong_tile].mask_t = 0;
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);
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_t = lr_t;
rdp.tiles(wrong_tile).mask_s = rdp.tiles(wrong_tile).mask_t = 0;
// 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);
rdp.tbuff_tex->tile_uls = ul_s;
@ -2255,20 +2255,20 @@ void rdp_loadtile()
if (g_settings->hacks(CSettings::hack_Tonic) && tile == 7)
{
rdp.tiles[0].ul_s = ul_s;
rdp.tiles[0].ul_t = ul_t;
rdp.tiles[0].lr_s = lr_s;
rdp.tiles[0].lr_t = lr_t;
rdp.tiles(0).ul_s = ul_s;
rdp.tiles(0).ul_t = ul_t;
rdp.tiles(0).lr_s = lr_s;
rdp.tiles(0).lr_t = lr_t;
}
uint32_t height = lr_t - ul_t + 1; // get height
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_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_height = (rdp.tiles[tile].mask_t ? minval((uint16_t)height, 1 << rdp.tiles[tile].mask_t) : (uint16_t)height);
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);
if (g_settings->hacks(CSettings::hack_MK64))
{
if (info.tile_width % 2)
@ -2283,9 +2283,9 @@ void rdp_loadtile()
info.tex_width = rdp.timg.width;
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;
offs += ul_s << rdp.tiles[tile].size >> 1;
offs += ul_s << rdp.tiles(tile).size >> 1;
offs += rdp.timg.addr;
if (offs >= BMASK)
return;
@ -2302,8 +2302,8 @@ void rdp_loadtile()
if (height == 0)
return;
uint32_t wid_64 = rdp.tiles[tile].line;
unsigned char *dst = ((unsigned char *)rdp.tmem) + (rdp.tiles[tile].t_mem << 3);
uint32_t wid_64 = rdp.tiles(tile).line;
unsigned char *dst = ((unsigned char *)rdp.tmem) + (rdp.tiles(tile).t_mem << 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);
}
@ -2312,7 +2312,7 @@ void rdp_loadtile()
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.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->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;
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)
v->u0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_s));
if (rdp.tiles(rdp.cur_tile).shift_s > 10)
v->u0 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile).shift_s));
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)
v->v0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_t));
if (rdp.tiles(rdp.cur_tile).shift_t > 10)
v->v0 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile).shift_t));
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->v0 -= rdp.tiles[rdp.cur_tile].f_ul_t;
v->u0 -= rdp.tiles(rdp.cur_tile).f_ul_s;
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->v0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_y * v->v0;
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.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)
v->u1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_s));
if (rdp.tiles(rdp.cur_tile + 1).shift_s > 10)
v->u1 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile + 1).shift_s));
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)
v->v1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_t));
if (rdp.tiles(rdp.cur_tile + 1).shift_t > 10)
v->v1 *= (float)(1 << (16 - rdp.tiles(rdp.cur_tile + 1).shift_t));
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->v1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_t;
v->u1 -= rdp.tiles(rdp.cur_tile + 1).f_ul_s;
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->v1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_y * v->v1;
v->u1 /= v->w;

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

@ -359,6 +359,7 @@ public:
bool init();
void free();
inline TILE & tiles(int index) { return m_tiles[index]; }
// Clipping
int clip; // clipping flags
VERTEX *vtx1; //[256] copy vertex buffer #1 (used for clipping)
@ -470,7 +471,9 @@ public:
// Textures
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
uint32_t addr[512]; // 512 addresses (used to determine address loaded from)
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 |= 8;
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)];
rdp.cur_tile = (ostate->textureState) & 7;
WriteTrace(TraceRDP, TraceDebug, "tile: %d", rdp.cur_tile);
if (rdp.tiles[rdp.cur_tile].s_scale < 0.001f)
rdp.tiles[rdp.cur_tile].s_scale = 0.015625;
if (rdp.tiles[rdp.cur_tile].t_scale < 0.001f)
rdp.tiles[rdp.cur_tile].t_scale = 0.015625;
if (rdp.tiles(rdp.cur_tile).s_scale < 0.001f)
rdp.tiles(rdp.cur_tile).s_scale = 0.015625;
if (rdp.tiles(rdp.cur_tile).t_scale < 0.001f)
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,
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->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 t = (uint16_t)(rdp.cmd1 & 0xFFFF);
TILE *tmp_tile = &rdp.tiles[tile];
TILE *tmp_tile = &rdp.tiles(tile);
tmp_tile->on = 1;
tmp_tile->org_s_scale = s;
tmp_tile->org_t_scale = t;
@ -775,7 +775,7 @@ void uc0_texture()
else
{
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->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;
}

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

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