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

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

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;

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