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

22
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);

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;

146
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));
@ -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;