[Glide64] Rename max and min to be maxval and minval
This commit is contained in:
zilmar
parent
834210eaf9
commit
09da116723
|
|
@ -125,8 +125,8 @@ void calc_sphere (VERTEX *v)
|
|||
int s_scale, t_scale;
|
||||
if (settings.hacks&hack_Chopper)
|
||||
{
|
||||
s_scale = min(rdp.tiles[rdp.cur_tile].org_s_scale >> 6, rdp.tiles[rdp.cur_tile].lr_s);
|
||||
t_scale = min(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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -669,9 +669,9 @@ COMBINE cmb;
|
|||
(uint8_t)( ((color1 & 0x0000FF00) >> 8) * (((color2 & 0x0000FF00) >> 8) /255.0f) ) << 8 ; \
|
||||
}
|
||||
#define CC_C1SUBC2(color1, color2) { \
|
||||
cmb.ccolor=(uint8_t)( max(0, (int)((color1 & 0xFF000000) >> 24) - (int)((color2 & 0xFF000000) >> 24)) ) << 24 | \
|
||||
(uint8_t)( max(0, (int)((color1 & 0x00FF0000) >> 16) - (int)((color2 & 0x00FF0000) >> 16)) ) << 16 | \
|
||||
(uint8_t)( max(0, (int)((color1 & 0x0000FF00) >> 8) - (int)((color2 & 0x0000FF00) >> 8)) ) << 8 ; \
|
||||
cmb.ccolor=(uint8_t)( maxval(0, (int)((color1 & 0xFF000000) >> 24) - (int)((color2 & 0xFF000000) >> 24)) ) << 24 | \
|
||||
(uint8_t)( maxval(0, (int)((color1 & 0x00FF0000) >> 16) - (int)((color2 & 0x00FF0000) >> 16)) ) << 16 | \
|
||||
(uint8_t)( maxval(0, (int)((color1 & 0x0000FF00) >> 8) - (int)((color2 & 0x0000FF00) >> 8)) ) << 8 ; \
|
||||
}
|
||||
#define CC_COLMULBYTE(color, byte) { \
|
||||
float factor = byte/255.0f; \
|
||||
|
|
@ -705,9 +705,9 @@ COMBINE cmb;
|
|||
rdp.cmb_flags |= flag; \
|
||||
}
|
||||
#define XSHADEC1MC2(color1, color2, flag) { \
|
||||
rdp.col[0] *= (float)( max(0, (int)((color1 & 0xFF000000) >> 24) - (int)((color2 & 0xFF000000) >> 24)) )/255.0f; \
|
||||
rdp.col[1] *= (float)( max(0, (int)((color1 & 0x00FF0000) >> 16) - (int)((color2 & 0x00FF0000) >> 16)) )/255.0f; \
|
||||
rdp.col[2] *= (float)( max(0, (int)((color1 & 0x0000FF00) >> 8) - (int)((color2 & 0x0000FF00) >> 8)) )/255.0f; \
|
||||
rdp.col[0] *= (float)( maxval(0, (int)((color1 & 0xFF000000) >> 24) - (int)((color2 & 0xFF000000) >> 24)) )/255.0f; \
|
||||
rdp.col[1] *= (float)( maxval(0, (int)((color1 & 0x00FF0000) >> 16) - (int)((color2 & 0x00FF0000) >> 16)) )/255.0f; \
|
||||
rdp.col[2] *= (float)( maxval(0, (int)((color1 & 0x0000FF00) >> 8) - (int)((color2 & 0x0000FF00) >> 8)) )/255.0f; \
|
||||
rdp.cmb_flags |= flag; \
|
||||
}
|
||||
#define XSHADE_BYTE(byte, flag) { \
|
||||
|
|
@ -756,9 +756,9 @@ COMBINE cmb;
|
|||
rdp.cmb_flags |= flag; \
|
||||
}
|
||||
#define XSHADEC1MC2ADD(color1, color2, flag) { \
|
||||
rdp.coladd[0] *= (float)( max(0, (int)((color1 & 0xFF000000) >> 24) - (int)((color2 & 0xFF000000) >> 24)) )/255.0f; \
|
||||
rdp.coladd[1] *= (float)( max(0, (int)((color1 & 0x00FF0000) >> 16) - (int)((color2 & 0x00FF0000) >> 16)) )/255.0f; \
|
||||
rdp.coladd[2] *= (float)( max(0, (int)((color1 & 0x0000FF00) >> 8) - (int)((color2 & 0x0000FF00) >> 8)) )/255.0f; \
|
||||
rdp.coladd[0] *= (float)( maxval(0, (int)((color1 & 0xFF000000) >> 24) - (int)((color2 & 0xFF000000) >> 24)) )/255.0f; \
|
||||
rdp.coladd[1] *= (float)( maxval(0, (int)((color1 & 0x00FF0000) >> 16) - (int)((color2 & 0x00FF0000) >> 16)) )/255.0f; \
|
||||
rdp.coladd[2] *= (float)( maxval(0, (int)((color1 & 0x0000FF00) >> 8) - (int)((color2 & 0x0000FF00) >> 8)) )/255.0f; \
|
||||
rdp.cmb_flags |= flag; \
|
||||
}
|
||||
#define SUBSHADE_PRIM() XSHADEADD(rdp.prim_color, CMB_SUB)
|
||||
|
|
@ -811,7 +811,7 @@ COMBINE cmb;
|
|||
rdp.cmb_flags |= flag; \
|
||||
}
|
||||
#define XSHADEC1MC2_A(color1, color2, flag) { \
|
||||
rdp.col[3] *= (float)( max(0, (int)(color1 & 0xFF) - (int)(color2 & 0xFF)) ) / 255.0f; \
|
||||
rdp.col[3] *= (float)( maxval(0, (int)(color1 & 0xFF) - (int)(color2 & 0xFF)) ) / 255.0f; \
|
||||
rdp.cmb_flags |= flag; \
|
||||
}
|
||||
#define MULSHADE_A_PRIM() XSHADE_A(rdp.prim_color, CMB_A_MULT)
|
||||
|
|
@ -1931,9 +1931,9 @@ static void cc__prim_inter_env_using_enva__mul_shade()
|
|||
uint32_t er = (rdp.env_color >> 24) & 0xFF;
|
||||
uint32_t eg = (rdp.env_color >> 16) & 0xFF;
|
||||
uint32_t eb = (rdp.env_color >> 8) & 0xFF;
|
||||
uint32_t r = min(255, (uint32_t)(er*ea + pr*ea_i));
|
||||
uint32_t g = min(255, (uint32_t)(eg*ea + pg*ea_i));
|
||||
uint32_t b = min(255, (uint32_t)(eb*ea + pb*ea_i));
|
||||
uint32_t r = minval(255, (uint32_t)(er*ea + pr*ea_i));
|
||||
uint32_t g = minval(255, (uint32_t)(eg*ea + pg*ea_i));
|
||||
uint32_t b = minval(255, (uint32_t)(eb*ea + pb*ea_i));
|
||||
uint32_t col = (r << 24) | (g << 16) | (b << 8) | 0xFF;
|
||||
CCMB(GR_COMBINE_FUNCTION_SCALE_OTHER,
|
||||
GR_COMBINE_FACTOR_LOCAL,
|
||||
|
|
@ -8557,9 +8557,9 @@ static void cc__prim_inter_one_using_env__mul_shade()
|
|||
GR_COMBINE_OTHER_CONSTANT);
|
||||
CC_1SUBPRIM();
|
||||
CC_C1MULC2(cmb.ccolor, rdp.env_color);
|
||||
cmb.ccolor = (uint8_t)(min(255, (int)((cmb.ccolor & 0xFF000000) >> 24) + (int)((rdp.prim_color & 0xFF000000) >> 24))) << 24 |
|
||||
(uint8_t)(min(255, (int)((cmb.ccolor & 0x00FF0000) >> 16) + (int)((rdp.prim_color & 0x00FF0000) >> 16))) << 16 |
|
||||
(uint8_t)(min(255, (int)((cmb.ccolor & 0x0000FF00) >> 8) + (int)((rdp.prim_color & 0x0000FF00) >> 8))) << 8;
|
||||
cmb.ccolor = (uint8_t)(minval(255, (int)((cmb.ccolor & 0xFF000000) >> 24) + (int)((rdp.prim_color & 0xFF000000) >> 24))) << 24 |
|
||||
(uint8_t)(minval(255, (int)((cmb.ccolor & 0x00FF0000) >> 16) + (int)((rdp.prim_color & 0x00FF0000) >> 16))) << 16 |
|
||||
(uint8_t)(minval(255, (int)((cmb.ccolor & 0x0000FF00) >> 8) + (int)((rdp.prim_color & 0x0000FF00) >> 8))) << 8;
|
||||
}
|
||||
|
||||
static void cc__env_inter_prim_using_t0a__mul_t0()
|
||||
|
|
|
|||
|
|
@ -159,7 +159,7 @@ static void DrawRE2Video256(FB_TO_SCREEN_INFO & fb_info)
|
|||
uint16_t * dst = tex;
|
||||
uint32_t col;
|
||||
uint8_t r, g, b;
|
||||
fb_info.height = min(256, fb_info.height);
|
||||
fb_info.height = minval(256, fb_info.height);
|
||||
for (uint32_t h = 0; h < fb_info.height; h++)
|
||||
{
|
||||
for (uint32_t w = 0; w < 256; w++)
|
||||
|
|
@ -308,7 +308,7 @@ bool DrawFrameBufferToScreen(FB_TO_SCREEN_INFO & fb_info)
|
|||
return false;
|
||||
uint32_t width = fb_info.lr_x - fb_info.ul_x + 1;
|
||||
uint32_t height = fb_info.lr_y - fb_info.ul_y + 1;
|
||||
uint32_t max_size = min(voodoo.max_tex_size, 512);
|
||||
uint32_t max_size = minval(voodoo.max_tex_size, 512);
|
||||
if (width > (uint32_t)max_size || height > (uint32_t)max_size)
|
||||
{
|
||||
DrawFrameBufferToScreen256(fb_info);
|
||||
|
|
|
|||
|
|
@ -802,7 +802,7 @@ void DisplayLoadProgress(const wchar_t *format, ...)
|
|||
float x;
|
||||
set_message_combiner();
|
||||
output(382, 380, 1, "LOADING TEXTURES. PLEASE WAIT...");
|
||||
int len = min((int)strlen(buf) * 8, 1024);
|
||||
int len = minval((int)strlen(buf) * 8, 1024);
|
||||
x = (1024 - len) / 2.0f;
|
||||
output(x, 360, 1, buf);
|
||||
grBufferSwap(0);
|
||||
|
|
|
|||
|
|
@ -55,14 +55,14 @@ static TBUFF_COLOR_IMAGE * AllocateTextureBuffer(COLOR_IMAGE & cimage)
|
|||
texbuf.height = cimage.height;
|
||||
texbuf.format = cimage.format;
|
||||
texbuf.size = cimage.size;
|
||||
texbuf.scr_width = min(cimage.width * rdp.scale_x, settings.scr_res_x);
|
||||
float height = min(rdp.vi_height, cimage.height);
|
||||
texbuf.scr_width = minval(cimage.width * rdp.scale_x, settings.scr_res_x);
|
||||
float height = minval(rdp.vi_height, cimage.height);
|
||||
if (cimage.status == ci_copy_self || (cimage.status == ci_copy && cimage.width == rdp.frame_buffers[rdp.main_ci_index].width))
|
||||
height = rdp.vi_height;
|
||||
texbuf.scr_height = height * rdp.scale_y;
|
||||
// texbuf.scr_height = texbuf.height * rdp.scale_y;
|
||||
|
||||
uint16_t max_size = max((uint16_t)texbuf.scr_width, (uint16_t)texbuf.scr_height);
|
||||
uint16_t max_size = maxval((uint16_t)texbuf.scr_width, (uint16_t)texbuf.scr_height);
|
||||
if (max_size > voodoo.max_tex_size) //texture size is too large
|
||||
return 0;
|
||||
uint32_t tex_size;
|
||||
|
|
|
|||
|
|
@ -215,28 +215,28 @@ void GetTexInfo(int id, int tile)
|
|||
if ((rdp.tiles[tile].clamp_s && tile_width <= 256) || (mask_width > 256))
|
||||
{
|
||||
// loading width
|
||||
width = min(mask_width, tile_width);
|
||||
width = minval(mask_width, tile_width);
|
||||
// actual width
|
||||
rdp.tiles[tile].width = tile_width;
|
||||
}
|
||||
else
|
||||
{
|
||||
// wrap all the way
|
||||
width = min(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;
|
||||
}
|
||||
|
||||
if ((rdp.tiles[tile].clamp_t && tile_height <= 256) || (mask_height > 256))
|
||||
{
|
||||
// loading height
|
||||
height = min(mask_height, tile_height);
|
||||
height = minval(mask_height, tile_height);
|
||||
// actual height
|
||||
rdp.tiles[tile].height = tile_height;
|
||||
}
|
||||
else
|
||||
{
|
||||
// wrap all the way
|
||||
height = min(mask_height, tile_height);
|
||||
height = minval(mask_height, tile_height);
|
||||
rdp.tiles[tile].height = height;
|
||||
}
|
||||
}
|
||||
|
|
@ -256,7 +256,7 @@ void GetTexInfo(int id, int tile)
|
|||
if ((rdp.tiles[tile].clamp_s && tile_width <= 256))//|| (mask_width > 256))
|
||||
{
|
||||
// loading width
|
||||
width = min(mask_width, tile_width);
|
||||
width = minval(mask_width, tile_width);
|
||||
// actual width
|
||||
rdp.tiles[tile].width = tile_width;
|
||||
}
|
||||
|
|
@ -270,7 +270,7 @@ void GetTexInfo(int id, int tile)
|
|||
if ((rdp.tiles[tile].clamp_t && tile_height <= 256) || (mask_height > 256))
|
||||
{
|
||||
// loading height
|
||||
height = min(mask_height, tile_height);
|
||||
height = minval(mask_height, tile_height);
|
||||
// actual height
|
||||
rdp.tiles[tile].height = tile_height;
|
||||
}
|
||||
|
|
@ -333,7 +333,7 @@ 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 + min(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)
|
||||
{
|
||||
LRDP("TEXTURE WRAPS TMEM!!! ");
|
||||
|
||||
|
|
@ -370,7 +370,7 @@ void GetTexInfo(int id, int tile)
|
|||
else //32b texture
|
||||
{
|
||||
int line_2 = line >> 1;
|
||||
int wid_64_2 = max(1, wid_64 >> 1);
|
||||
int wid_64_2 = maxval(1, wid_64 >> 1);
|
||||
crc = textureCRC(addr, wid_64_2, crc_height, line_2);
|
||||
crc += textureCRC(addr + 0x800, wid_64_2, crc_height, line_2);
|
||||
}
|
||||
|
|
@ -380,7 +380,7 @@ void GetTexInfo(int id, int tile)
|
|||
{
|
||||
crc = 0xFFFFFFFF;
|
||||
wxUIntPtr addr = wxPtrToUInt(rdp.tmem) + (rdp.tiles[tile].t_mem << 3);
|
||||
uint32_t line2 = max(line, 1);
|
||||
uint32_t line2 = maxval(line, 1);
|
||||
if (rdp.tiles[tile].size < 3)
|
||||
{
|
||||
line2 <<= 3;
|
||||
|
|
@ -395,7 +395,7 @@ void GetTexInfo(int id, int tile)
|
|||
line2 <<= 2;
|
||||
//32b texel is split in two 16b parts, so bpl/2 and line/2.
|
||||
//Min value for bpl is 4, because when width==1 first 2 bytes of tmem will not be used.
|
||||
bpl = max(bpl >> 1, 4);
|
||||
bpl = maxval(bpl >> 1, 4);
|
||||
for (int y = 0; y < crc_height; y++)
|
||||
{
|
||||
crc = CRC32(crc, reinterpret_cast<void*>(addr), bpl);
|
||||
|
|
@ -981,9 +981,9 @@ uint32_t sizeBytes[4] = { 0, 1, 2, 4 };
|
|||
inline uint32_t Txl2Words(uint32_t width, uint32_t size)
|
||||
{
|
||||
if (size == 0)
|
||||
return max(1, width / 16);
|
||||
return maxval(1, width / 16);
|
||||
else
|
||||
return max(1, width*sizeBytes[size] / 8);
|
||||
return maxval(1, width*sizeBytes[size] / 8);
|
||||
}
|
||||
|
||||
inline uint32_t ReverseDXT(uint32_t val, uint32_t /*lrs*/, uint32_t width, uint32_t size)
|
||||
|
|
@ -1101,7 +1101,7 @@ void LoadTex(int id, int tmu)
|
|||
}
|
||||
|
||||
// Calculate the maximum size
|
||||
int size_max = max(size_x, size_y);
|
||||
int size_max = maxval(size_x, size_y);
|
||||
uint32_t real_x = size_max, real_y = size_max;
|
||||
switch (size_max)
|
||||
{
|
||||
|
|
@ -1308,7 +1308,7 @@ void LoadTex(int id, int tmu)
|
|||
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 = min(info.tile_width, info.tex_width);
|
||||
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;
|
||||
|
||||
|
|
@ -1409,11 +1409,11 @@ void LoadTex(int id, int tmu)
|
|||
|
||||
int min_x, min_y;
|
||||
if (rdp.tiles[td].mask_s != 0)
|
||||
min_x = min((int)real_x, 1 << rdp.tiles[td].mask_s);
|
||||
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 = min((int)real_y, 1 << rdp.tiles[td].mask_t);
|
||||
min_y = minval((int)real_y, 1 << rdp.tiles[td].mask_t);
|
||||
else
|
||||
min_y = real_y;
|
||||
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ uint32_t Load32bRGBA (wxUIntPtr dst, wxUIntPtr src, int wid_64, int height, int
|
|||
if (height < 1) height = 1;
|
||||
const uint16_t *tmem16 = (uint16_t*)rdp.tmem;
|
||||
const uint32_t tbase = (src - (wxUIntPtr)rdp.tmem) >> 1;
|
||||
const uint32_t width = max(1, wid_64 << 1);
|
||||
const uint32_t width = maxval(1, wid_64 << 1);
|
||||
const int ext = real_width - width;
|
||||
line = width + (line>>2);
|
||||
uint32_t s, t, c;
|
||||
|
|
|
|||
|
|
@ -132,9 +132,9 @@ static void mod_col_inter_col1_using_tex (uint16_t *dst, int size, uint32_t colo
|
|||
percent_r = ((col >> 8) & 0xF) / 15.0f;
|
||||
percent_g = ((col >> 4) & 0xF) / 15.0f;
|
||||
percent_b = (col & 0xF) / 15.0f;
|
||||
r = min(15, (uint8_t)((1.0f-percent_r) * cr0 + percent_r * cr1 + 0.0001f));
|
||||
g = min(15, (uint8_t)((1.0f-percent_g) * cg0 + percent_g * cg1 + 0.0001f));
|
||||
b = min(15, (uint8_t)((1.0f-percent_b) * cb0 + percent_b * cb1 + 0.0001f));
|
||||
r = minval(15, (uint8_t)((1.0f-percent_r) * cr0 + percent_r * cr1 + 0.0001f));
|
||||
g = minval(15, (uint8_t)((1.0f-percent_g) * cg0 + percent_g * cg1 + 0.0001f));
|
||||
b = minval(15, (uint8_t)((1.0f-percent_b) * cb0 + percent_b * cb1 + 0.0001f));
|
||||
*(dst++) = a | (r << 8) | (g << 4) | b;
|
||||
}
|
||||
}
|
||||
|
|
@ -312,15 +312,15 @@ static void mod_tex_sub_col_mul_fac_add_tex (uint16_t *dst, int size, uint32_t c
|
|||
col = *dst;
|
||||
a = col & 0xF000;
|
||||
r = (float)((col >> 8) & 0xF);
|
||||
r = /*max(*/(r - cr) * percent/*, 0.0f)*/ + r;
|
||||
r = /*maxval(*/(r - cr) * percent/*, 0.0f)*/ + r;
|
||||
if (r > 15.0f) r = 15.0f;
|
||||
if (r < 0.0f) r = 0.0f;
|
||||
g = (float)((col >> 4) & 0xF);
|
||||
g = /*max(*/(g - cg) * percent/*, 0.0f)*/ + g;
|
||||
g = /*maxval(*/(g - cg) * percent/*, 0.0f)*/ + g;
|
||||
if (g > 15.0f) g = 15.0f;
|
||||
if (g < 0.0f) g = 0.0f;
|
||||
b = (float)(col & 0xF);
|
||||
b = /*max(*/(b - cb) * percent/*, 0.0f)*/ + b;
|
||||
b = /*maxval(*/(b - cb) * percent/*, 0.0f)*/ + b;
|
||||
if (b > 15.0f) b = 15.0f;
|
||||
if (b < 0.0f) b = 0.0f;
|
||||
|
||||
|
|
@ -350,9 +350,9 @@ static void mod_tex_scale_col_add_col (uint16_t *dst, int size, uint32_t color0,
|
|||
percent_r = ((col >> 8) & 0xF) / 15.0f;
|
||||
percent_g = ((col >> 4) & 0xF) / 15.0f;
|
||||
percent_b = (col & 0xF) / 15.0f;
|
||||
r = min(15, (uint8_t)(percent_r * cr0 + cr1 + 0.0001f));
|
||||
g = min(15, (uint8_t)(percent_g * cg0 + cg1 + 0.0001f));
|
||||
b = min(15, (uint8_t)(percent_b * cb0 + cb1 + 0.0001f));
|
||||
r = minval(15, (uint8_t)(percent_r * cr0 + cr1 + 0.0001f));
|
||||
g = minval(15, (uint8_t)(percent_g * cg0 + cg1 + 0.0001f));
|
||||
b = minval(15, (uint8_t)(percent_b * cb0 + cb1 + 0.0001f));
|
||||
*(dst++) = a | (r << 8) | (g << 4) | b;
|
||||
}
|
||||
}
|
||||
|
|
@ -417,9 +417,9 @@ static void mod_tex_sub_col (uint16_t *dst, int size, uint32_t color)
|
|||
{
|
||||
col = *dst;
|
||||
a = (uint8_t)(col & 0xF000);
|
||||
r = (uint8_t)max((((col >> 8) & 0xF) - cr), 0);
|
||||
g = (uint8_t)max((((col >> 4) & 0xF) - cg), 0);
|
||||
b = (uint8_t)max(((col & 0xF) - cb), 0);
|
||||
r = (uint8_t)maxval((((col >> 8) & 0xF) - cr), 0);
|
||||
g = (uint8_t)maxval((((col >> 4) & 0xF) - cg), 0);
|
||||
b = (uint8_t)maxval(((col & 0xF) - cb), 0);
|
||||
*(dst++) = (a << 12) | (r << 8) | (g << 4) | b;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,9 +56,9 @@ static void mod_tex_inter_color_using_factor_CI (uint32_t color, uint32_t factor
|
|||
r = (uint8_t)((float)((col&0xF800) >> 11) / 31.0f * 255.0f);
|
||||
g = (uint8_t)((float)((col&0x07C0) >> 6) / 31.0f * 255.0f);
|
||||
b = (uint8_t)((float)((col&0x003E) >> 1) / 31.0f * 255.0f);
|
||||
r = (uint8_t)(min(255, percent_i * r + percent * cr));
|
||||
g = (uint8_t)(min(255, percent_i * g + percent * cg));
|
||||
b = (uint8_t)(min(255, percent_i * b + percent * cb));
|
||||
r = (uint8_t)(minval(255, percent_i * r + percent * cr));
|
||||
g = (uint8_t)(minval(255, percent_i * g + percent * cg));
|
||||
b = (uint8_t)(minval(255, percent_i * b + percent * cb));
|
||||
rdp.pal_8[i] = (uint16_t)(((uint16_t)(r >> 3) << 11) |
|
||||
((uint16_t)(g >> 3) << 6) |
|
||||
((uint16_t)(b >> 3) << 1) |
|
||||
|
|
@ -90,9 +90,9 @@ static void mod_tex_inter_col_using_col1_CI (uint32_t color0, uint32_t color1)
|
|||
r = (uint8_t)((float)((col&0xF800) >> 11) / 31.0f * 255.0f);
|
||||
g = (uint8_t)((float)((col&0x07C0) >> 6) / 31.0f * 255.0f);
|
||||
b = (uint8_t)((float)((col&0x003E) >> 1) / 31.0f * 255.0f);
|
||||
r = (uint8_t)(min(255, percent_r_i * r + percent_r * cr));
|
||||
g = (uint8_t)(min(255, percent_g_i * g + percent_g * cg));
|
||||
b = (uint8_t)(min(255, percent_b_i * b + percent_b * cb));
|
||||
r = (uint8_t)(minval(255, percent_r_i * r + percent_r * cr));
|
||||
g = (uint8_t)(minval(255, percent_g_i * g + percent_g * cg));
|
||||
b = (uint8_t)(minval(255, percent_b_i * b + percent_b * cb));
|
||||
rdp.pal_8[i] = (uint16_t)(((uint16_t)(r >> 3) << 11) |
|
||||
((uint16_t)(g >> 3) << 6) |
|
||||
((uint16_t)(b >> 3) << 1) |
|
||||
|
|
@ -118,10 +118,10 @@ static void mod_full_color_sub_tex_CI (uint32_t color)
|
|||
r = (uint8_t)((float)((col&0xF800) >> 11) / 31.0f * 255.0f);
|
||||
g = (uint8_t)((float)((col&0x07C0) >> 6) / 31.0f * 255.0f);
|
||||
b = (uint8_t)((float)((col&0x003E) >> 1) / 31.0f * 255.0f);
|
||||
a = max(0, ca - a);
|
||||
r = max(0, cr - r);
|
||||
g = max(0, cg - g);
|
||||
b = max(0, cb - b);
|
||||
a = maxval(0, ca - a);
|
||||
r = maxval(0, cr - r);
|
||||
g = maxval(0, cg - g);
|
||||
b = maxval(0, cb - b);
|
||||
rdp.pal_8[i] = (uint16_t)(((uint16_t)(r >> 3) << 11) |
|
||||
((uint16_t)(g >> 3) << 6) |
|
||||
((uint16_t)(b >> 3) << 1) |
|
||||
|
|
@ -150,9 +150,9 @@ static void mod_col_inter_col1_using_tex_CI (uint32_t color0, uint32_t color1)
|
|||
percent_r = ((col&0xF800) >> 11) / 31.0f;
|
||||
percent_g = ((col&0x07C0) >> 6) / 31.0f;
|
||||
percent_b = ((col&0x003E) >> 1) / 31.0f;
|
||||
r = (uint8_t)(min((1.0f-percent_r) * cr0 + percent_r * cr1, 255));
|
||||
g = (uint8_t)(min((1.0f-percent_g) * cg0 + percent_g * cg1, 255));
|
||||
b = (uint8_t)(min((1.0f-percent_b) * cb0 + percent_b * cb1, 255));
|
||||
r = (uint8_t)(minval((1.0f-percent_r) * cr0 + percent_r * cr1, 255));
|
||||
g = (uint8_t)(minval((1.0f-percent_g) * cg0 + percent_g * cg1, 255));
|
||||
b = (uint8_t)(minval((1.0f-percent_b) * cb0 + percent_b * cb1, 255));
|
||||
rdp.pal_8[i] = (uint16_t)(((uint16_t)(r >> 3) << 11) |
|
||||
((uint16_t)(g >> 3) << 6) |
|
||||
((uint16_t)(b >> 3) << 1) |
|
||||
|
|
@ -216,9 +216,9 @@ static void mod_tex_scale_col_add_col_CI (uint32_t color0, uint32_t color1)
|
|||
r = (uint8_t)((float)((col&0xF800) >> 11) / 31.0f * 255.0f);
|
||||
g = (uint8_t)((float)((col&0x07C0) >> 6) / 31.0f * 255.0f);
|
||||
b = (uint8_t)((float)((col&0x003E) >> 1) / 31.0f * 255.0f);
|
||||
r = (uint8_t)(min(255, percent_r * r + cr));
|
||||
g = (uint8_t)(min(255, percent_g * g + cg));
|
||||
b = (uint8_t)(min(255, percent_b * b + cb));
|
||||
r = (uint8_t)(minval(255, percent_r * r + cr));
|
||||
g = (uint8_t)(minval(255, percent_g * g + cg));
|
||||
b = (uint8_t)(minval(255, percent_b * b + cb));
|
||||
rdp.pal_8[i] = (uint16_t)(((uint16_t)(r >> 3) << 11) |
|
||||
((uint16_t)(g >> 3) << 6) |
|
||||
((uint16_t)(b >> 3) << 1) |
|
||||
|
|
@ -243,9 +243,9 @@ static void mod_tex_add_col_CI (uint32_t color)
|
|||
r = (uint8_t)((float)((col&0xF800) >> 11) / 31.0f * 255.0f);
|
||||
g = (uint8_t)((float)((col&0x07C0) >> 6) / 31.0f * 255.0f);
|
||||
b = (uint8_t)((float)((col&0x003E) >> 1) / 31.0f * 255.0f);
|
||||
r = min(cr + r, 255);
|
||||
g = min(cg + g, 255);
|
||||
b = min(cb + b, 255);
|
||||
r = minval(cr + r, 255);
|
||||
g = minval(cg + g, 255);
|
||||
b = minval(cb + b, 255);
|
||||
rdp.pal_8[i] = (uint16_t)(((uint16_t)(r >> 3) << 11) |
|
||||
((uint16_t)(g >> 3) << 6) |
|
||||
((uint16_t)(b >> 3) << 1) |
|
||||
|
|
@ -270,9 +270,9 @@ static void mod_tex_sub_col_CI (uint32_t color)
|
|||
r = (uint8_t)((float)((col&0xF800) >> 11) / 31.0f * 255.0f);
|
||||
g = (uint8_t)((float)((col&0x07C0) >> 6) / 31.0f * 255.0f);
|
||||
b = (uint8_t)((float)((col&0x003E) >> 1) / 31.0f * 255.0f);
|
||||
r = max(r - cr, 0);
|
||||
g = max(g - cg, 0);
|
||||
b = max(b - cb, 0);
|
||||
r = maxval(r - cr, 0);
|
||||
g = maxval(g - cg, 0);
|
||||
b = maxval(b - cb, 0);
|
||||
rdp.pal_8[i] = (uint16_t)(((uint16_t)(r >> 3) << 11) |
|
||||
((uint16_t)(g >> 3) << 6) |
|
||||
((uint16_t)(b >> 3) << 1) |
|
||||
|
|
@ -340,9 +340,9 @@ static void mod_col_inter_tex_using_col1_CI (uint32_t color0, uint32_t color1)
|
|||
r = (uint8_t)((float)((col&0xF800) >> 11) / 31.0f * 255.0f);
|
||||
g = (uint8_t)((float)((col&0x07C0) >> 6) / 31.0f * 255.0f);
|
||||
b = (uint8_t)((float)((col&0x003E) >> 1) / 31.0f * 255.0f);
|
||||
r = (uint8_t)(min(255, percent_r * r + percent_r_i * cr));
|
||||
g = (uint8_t)(min(255, percent_g * g + percent_g_i * cg));
|
||||
b = (uint8_t)(min(255, percent_b * b + percent_b_i * cb));
|
||||
r = (uint8_t)(minval(255, percent_r * r + percent_r_i * cr));
|
||||
g = (uint8_t)(minval(255, percent_g * g + percent_g_i * cg));
|
||||
b = (uint8_t)(minval(255, percent_b * b + percent_b_i * cb));
|
||||
rdp.pal_8[i] = (uint16_t)(((uint16_t)(r >> 3) << 11) |
|
||||
((uint16_t)(g >> 3) << 6) |
|
||||
((uint16_t)(b >> 3) << 1) |
|
||||
|
|
|
|||
|
|
@ -311,7 +311,7 @@ void draw_tri(VERTEX **vtx, uint16_t linew)
|
|||
double fdz = fabs(fdzdx) + fabs(fdzdy);
|
||||
if ((settings.hacks & hack_Zelda) && (rdp.rm & 0x800))
|
||||
fdz *= 4.0; // Decal mode in Zelda sometimes needs mutiplied deltaZ to work correct, e.g. roads
|
||||
deltaZ = max(8, (int)fdz);
|
||||
deltaZ = maxval(8, (int)fdz);
|
||||
}
|
||||
dzdx = (int)(fdzdx * 65536.0);
|
||||
}
|
||||
|
|
@ -336,7 +336,7 @@ void draw_tri(VERTEX **vtx, uint16_t linew)
|
|||
{
|
||||
if (rdp.geom_mode & 0x00000004) // flat shading
|
||||
{
|
||||
int flag = min(2, (rdp.cmd1 >> 24) & 3);
|
||||
int flag = minval(2, (rdp.cmd1 >> 24) & 3);
|
||||
v->a = vtx[flag]->a;
|
||||
v->b = vtx[flag]->b;
|
||||
v->g = vtx[flag]->g;
|
||||
|
|
@ -486,11 +486,11 @@ void draw_tri(VERTEX **vtx, uint16_t linew)
|
|||
int index, i, j, min_256, max_256, cur_256, left_256, right_256;
|
||||
float percent;
|
||||
|
||||
min_256 = min((int)vtx[0]->u0, (int)vtx[1]->u0); // bah, don't put two mins on one line
|
||||
min_256 = min(min_256, (int)vtx[2]->u0) >> 8; // or it will be calculated twice
|
||||
min_256 = minval((int)vtx[0]->u0, (int)vtx[1]->u0); // bah, don't put two mins on one line
|
||||
min_256 = minval(min_256, (int)vtx[2]->u0) >> 8; // or it will be calculated twice
|
||||
|
||||
max_256 = max((int)vtx[0]->u0, (int)vtx[1]->u0); // not like it makes much difference
|
||||
max_256 = max(max_256, (int)vtx[2]->u0) >> 8; // anyway :P
|
||||
max_256 = maxval((int)vtx[0]->u0, (int)vtx[1]->u0); // not like it makes much difference
|
||||
max_256 = maxval(max_256, (int)vtx[2]->u0) >> 8; // anyway :P
|
||||
|
||||
for (cur_256 = min_256; cur_256 <= max_256; cur_256++)
|
||||
{
|
||||
|
|
@ -1012,11 +1012,11 @@ static void CalculateLOD(VERTEX *v, int n)
|
|||
lodFactor = lodFactor / n;
|
||||
}
|
||||
int ilod = (int)lodFactor;
|
||||
int lod_tile = min((int)(log10f((float)ilod) / log10f(2.0f)), rdp.cur_tile + rdp.mipmap_level);
|
||||
int lod_tile = minval((int)(log10f((float)ilod) / log10f(2.0f)), rdp.cur_tile + rdp.mipmap_level);
|
||||
float lod_fraction = 1.0f;
|
||||
if (lod_tile < rdp.cur_tile + rdp.mipmap_level)
|
||||
{
|
||||
lod_fraction = max((float)modf(lodFactor / pow(2., lod_tile), &intptr), rdp.prim_lodmin / 255.0f);
|
||||
lod_fraction = maxval((float)modf(lodFactor / pow(2., lod_tile), &intptr), rdp.prim_lodmin / 255.0f);
|
||||
}
|
||||
float detailmax;
|
||||
if (cmb.dc0_detailmax < 0.5f)
|
||||
|
|
@ -1586,12 +1586,12 @@ static void render_tri(uint16_t linew, int old_interpolate)
|
|||
{
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
rdp.vtxbuf[i].f = 1.0f / max(4.0f, rdp.vtxbuf[i].f);
|
||||
rdp.vtxbuf[i].f = 1.0f / maxval(4.0f, rdp.vtxbuf[i].f);
|
||||
}
|
||||
}
|
||||
else if (rdp.fog_mode == RDP::fog_blend)
|
||||
{
|
||||
float fog = 1.0f / max(1, rdp.fog_color & 0xFF);
|
||||
float fog = 1.0f / maxval(1, rdp.fog_color & 0xFF);
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
rdp.vtxbuf[i].f = fog;
|
||||
|
|
@ -1599,7 +1599,7 @@ static void render_tri(uint16_t linew, int old_interpolate)
|
|||
}
|
||||
else if (rdp.fog_mode == RDP::fog_blend_inverse)
|
||||
{
|
||||
float fog = 1.0f / max(1, (~rdp.fog_color) & 0xFF);
|
||||
float fog = 1.0f / maxval(1, (~rdp.fog_color) & 0xFF);
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
rdp.vtxbuf[i].f = fog;
|
||||
|
|
@ -1782,10 +1782,10 @@ void update_scissor()
|
|||
rdp.update ^= UPDATE_SCISSOR;
|
||||
|
||||
// KILL the floating point error with 0.01f
|
||||
rdp.scissor.ul_x = (uint32_t)max(min((rdp.scissor_o.ul_x * rdp.scale_x + rdp.offset_x + 0.01f), settings.res_x), 0);
|
||||
rdp.scissor.lr_x = (uint32_t)max(min((rdp.scissor_o.lr_x * rdp.scale_x + rdp.offset_x + 0.01f), settings.res_x), 0);
|
||||
rdp.scissor.ul_y = (uint32_t)max(min((rdp.scissor_o.ul_y * rdp.scale_y + rdp.offset_y + 0.01f), settings.res_y), 0);
|
||||
rdp.scissor.lr_y = (uint32_t)max(min((rdp.scissor_o.lr_y * rdp.scale_y + rdp.offset_y + 0.01f), settings.res_y), 0);
|
||||
rdp.scissor.ul_x = (uint32_t)maxval(minval((rdp.scissor_o.ul_x * rdp.scale_x + rdp.offset_x + 0.01f), settings.res_x), 0);
|
||||
rdp.scissor.lr_x = (uint32_t)maxval(minval((rdp.scissor_o.lr_x * rdp.scale_x + rdp.offset_x + 0.01f), settings.res_x), 0);
|
||||
rdp.scissor.ul_y = (uint32_t)maxval(minval((rdp.scissor_o.ul_y * rdp.scale_y + rdp.offset_y + 0.01f), settings.res_y), 0);
|
||||
rdp.scissor.lr_y = (uint32_t)maxval(minval((rdp.scissor_o.lr_y * rdp.scale_y + rdp.offset_y + 0.01f), settings.res_y), 0);
|
||||
//grClipWindow specifies the hardware clipping window. Any pixels outside the clipping window are rejected.
|
||||
//Values are inclusive for minimum x and y values and exclusive for maximum x and y values.
|
||||
// grClipWindow (rdp.scissor.ul_x?rdp.scissor.ul_x+1:0, rdp.scissor.ul_y?rdp.scissor.ul_y+1:0, rdp.scissor.lr_x, rdp.scissor.lr_y);
|
||||
|
|
@ -2095,10 +2095,10 @@ void update()
|
|||
float scale_x = (float)fabs(rdp.view_scale[0]);
|
||||
float scale_y = (float)fabs(rdp.view_scale[1]);
|
||||
|
||||
rdp.clip_min_x = max((rdp.view_trans[0] - scale_x + rdp.offset_x) / rdp.clip_ratio, 0.0f);
|
||||
rdp.clip_min_y = max((rdp.view_trans[1] - scale_y + rdp.offset_y) / rdp.clip_ratio, 0.0f);
|
||||
rdp.clip_max_x = min((rdp.view_trans[0] + scale_x + rdp.offset_x) * rdp.clip_ratio, settings.res_x);
|
||||
rdp.clip_max_y = min((rdp.view_trans[1] + scale_y + rdp.offset_y) * rdp.clip_ratio, settings.res_y);
|
||||
rdp.clip_min_x = maxval((rdp.view_trans[0] - scale_x + rdp.offset_x) / rdp.clip_ratio, 0.0f);
|
||||
rdp.clip_min_y = maxval((rdp.view_trans[1] - scale_y + rdp.offset_y) / rdp.clip_ratio, 0.0f);
|
||||
rdp.clip_max_x = minval((rdp.view_trans[0] + scale_x + rdp.offset_x) * rdp.clip_ratio, settings.res_x);
|
||||
rdp.clip_max_y = minval((rdp.view_trans[1] + scale_y + rdp.offset_y) * rdp.clip_ratio, settings.res_y);
|
||||
|
||||
FRDP(" |- viewport - (%d, %d, %d, %d)\n", (uint32_t)rdp.clip_min_x, (uint32_t)rdp.clip_min_y, (uint32_t)rdp.clip_max_x, (uint32_t)rdp.clip_max_y);
|
||||
if (!rdp.scissor_set)
|
||||
|
|
|
|||
|
|
@ -479,8 +479,8 @@ static void CopyFrameBuffer(GrBuffer_t buffer = GR_BUFFER_BACKBUFFER)
|
|||
}
|
||||
else
|
||||
{
|
||||
float scale_x = (settings.scr_res_x - rdp.offset_x*2.0f) / max(width, rdp.vi_width);
|
||||
float scale_y = (settings.scr_res_y - rdp.offset_y*2.0f) / max(height, rdp.vi_height);
|
||||
float scale_x = (settings.scr_res_x - rdp.offset_x*2.0f) / maxval(width, rdp.vi_width);
|
||||
float scale_y = (settings.scr_res_y - rdp.offset_y*2.0f) / maxval(height, rdp.vi_height);
|
||||
|
||||
FRDP("width: %d, height: %d, ul_y: %d, lr_y: %d, scale_x: %f, scale_y: %f, ci_width: %d, ci_height: %d\n", width, height, rdp.ci_upper_bound, rdp.ci_lower_bound, scale_x, scale_y, rdp.ci_width, rdp.ci_height);
|
||||
GrLfbInfo_t info;
|
||||
|
|
@ -582,7 +582,7 @@ EXPORT void CALL ProcessDList(void)
|
|||
{
|
||||
hhkLowLevelKybd = SetWindowsHookEx(WH_KEYBOARD_LL,
|
||||
LowLevelKeyboardProc, hInstance, 0);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
LOG("ProcessDList ()\n");
|
||||
|
|
@ -642,7 +642,7 @@ EXPORT void CALL ProcessDList(void)
|
|||
|
||||
rdp.model_i = 0; // 0 matrices so far in stack
|
||||
//stack_size can be less then 32! Important for Silicon Vally. Thanks Orkin!
|
||||
rdp.model_stack_size = min(32, (*(uint32_t*)(gfx.DMEM + 0x0FE4)) >> 6);
|
||||
rdp.model_stack_size = minval(32, (*(uint32_t*)(gfx.DMEM + 0x0FE4)) >> 6);
|
||||
if (rdp.model_stack_size == 0)
|
||||
rdp.model_stack_size = 32;
|
||||
rdp.Persp_en = TRUE;
|
||||
|
|
@ -784,7 +784,7 @@ EXPORT void CALL ProcessDList(void)
|
|||
to_fullscreen = TRUE;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (fb_emulation_enabled)
|
||||
|
|
@ -807,7 +807,7 @@ EXPORT void CALL ProcessDList(void)
|
|||
CI_SET = FALSE;
|
||||
}
|
||||
LRDP("ProcessDList end\n");
|
||||
}
|
||||
}
|
||||
|
||||
// undef - undefined instruction, always ignore
|
||||
static void undef()
|
||||
|
|
@ -995,17 +995,17 @@ static void rdp_texrect()
|
|||
float ul_x, ul_y, lr_x, lr_y;
|
||||
if (rdp.cycle_mode == 2)
|
||||
{
|
||||
ul_x = max(0.0f, (short)((rdp.cmd1 & 0x00FFF000) >> 14));
|
||||
ul_y = max(0.0f, (short)((rdp.cmd1 & 0x00000FFF) >> 2));
|
||||
lr_x = max(0.0f, (short)((rdp.cmd0 & 0x00FFF000) >> 14));
|
||||
lr_y = max(0.0f, (short)((rdp.cmd0 & 0x00000FFF) >> 2));
|
||||
ul_x = maxval(0.0f, (short)((rdp.cmd1 & 0x00FFF000) >> 14));
|
||||
ul_y = maxval(0.0f, (short)((rdp.cmd1 & 0x00000FFF) >> 2));
|
||||
lr_x = maxval(0.0f, (short)((rdp.cmd0 & 0x00FFF000) >> 14));
|
||||
lr_y = maxval(0.0f, (short)((rdp.cmd0 & 0x00000FFF) >> 2));
|
||||
}
|
||||
else
|
||||
{
|
||||
ul_x = max(0.0f, ((short)((rdp.cmd1 & 0x00FFF000) >> 12)) / 4.0f);
|
||||
ul_y = max(0.0f, ((short)(rdp.cmd1 & 0x00000FFF)) / 4.0f);
|
||||
lr_x = max(0.0f, ((short)((rdp.cmd0 & 0x00FFF000) >> 12)) / 4.0f);
|
||||
lr_y = max(0.0f, ((short)(rdp.cmd0 & 0x00000FFF)) / 4.0f);
|
||||
ul_x = maxval(0.0f, ((short)((rdp.cmd1 & 0x00FFF000) >> 12)) / 4.0f);
|
||||
ul_y = maxval(0.0f, ((short)(rdp.cmd1 & 0x00000FFF)) / 4.0f);
|
||||
lr_x = maxval(0.0f, ((short)((rdp.cmd0 & 0x00FFF000) >> 12)) / 4.0f);
|
||||
lr_y = maxval(0.0f, ((short)(rdp.cmd0 & 0x00000FFF)) / 4.0f);
|
||||
}
|
||||
|
||||
if (ul_x >= lr_x)
|
||||
|
|
@ -1420,9 +1420,9 @@ static void rdp_texrect()
|
|||
{
|
||||
float fog;
|
||||
if (rdp.fog_mode == RDP::fog_blend)
|
||||
fog = 1.0f / max(1, rdp.fog_color & 0xFF);
|
||||
fog = 1.0f / maxval(1, rdp.fog_color & 0xFF);
|
||||
else
|
||||
fog = 1.0f / max(1, (~rdp.fog_color) & 0xFF);
|
||||
fog = 1.0f / maxval(1, (~rdp.fog_color) & 0xFF);
|
||||
for (i = 0; i < n_vertices; i++)
|
||||
{
|
||||
vptr[i].f = fog;
|
||||
|
|
@ -1531,10 +1531,10 @@ static void rdp_setconvert()
|
|||
static void rdp_setscissor()
|
||||
{
|
||||
// clipper resolution is 320x240, scale based on computer resolution
|
||||
rdp.scissor_o.ul_x = /*min(*/(uint32_t)(((rdp.cmd0 & 0x00FFF000) >> 14))/*, 320)*/;
|
||||
rdp.scissor_o.ul_y = /*min(*/(uint32_t)(((rdp.cmd0 & 0x00000FFF) >> 2))/*, 240)*/;
|
||||
rdp.scissor_o.lr_x = /*min(*/(uint32_t)(((rdp.cmd1 & 0x00FFF000) >> 14))/*, 320)*/;
|
||||
rdp.scissor_o.lr_y = /*min(*/(uint32_t)(((rdp.cmd1 & 0x00000FFF) >> 2))/*, 240)*/;
|
||||
rdp.scissor_o.ul_x = /*minval(*/(uint32_t)(((rdp.cmd0 & 0x00FFF000) >> 14))/*, 320)*/;
|
||||
rdp.scissor_o.ul_y = /*minval(*/(uint32_t)(((rdp.cmd0 & 0x00000FFF) >> 2))/*, 240)*/;
|
||||
rdp.scissor_o.lr_x = /*minval(*/(uint32_t)(((rdp.cmd1 & 0x00FFF000) >> 14))/*, 320)*/;
|
||||
rdp.scissor_o.lr_y = /*minval(*/(uint32_t)(((rdp.cmd1 & 0x00000FFF) >> 2))/*, 240)*/;
|
||||
|
||||
rdp.ci_upper_bound = rdp.scissor_o.ul_y;
|
||||
rdp.ci_lower_bound = rdp.scissor_o.lr_y;
|
||||
|
|
@ -2145,8 +2145,8 @@ static void rdp_loadtile()
|
|||
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 ? min((uint16_t)width, 1 << rdp.tiles[tile].mask_s) : (uint16_t)width);
|
||||
info.tile_height = (rdp.tiles[tile].mask_t ? min((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 (settings.hacks&hack_MK64) {
|
||||
if (info.tile_width % 2)
|
||||
info.tile_width--;
|
||||
|
|
@ -2275,10 +2275,10 @@ static void rdp_fillrect()
|
|||
}
|
||||
//if (settings.frame_buffer&fb_depth_clear)
|
||||
{
|
||||
ul_x = min(max(ul_x, rdp.scissor_o.ul_x), rdp.scissor_o.lr_x);
|
||||
lr_x = min(max(lr_x, rdp.scissor_o.ul_x), rdp.scissor_o.lr_x);
|
||||
ul_y = min(max(ul_y, rdp.scissor_o.ul_y), rdp.scissor_o.lr_y);
|
||||
lr_y = min(max(lr_y, rdp.scissor_o.ul_y), rdp.scissor_o.lr_y);
|
||||
ul_x = minval(maxval(ul_x, rdp.scissor_o.ul_x), rdp.scissor_o.lr_x);
|
||||
lr_x = minval(maxval(lr_x, rdp.scissor_o.ul_x), rdp.scissor_o.lr_x);
|
||||
ul_y = minval(maxval(ul_y, rdp.scissor_o.ul_y), rdp.scissor_o.lr_y);
|
||||
lr_y = minval(maxval(lr_y, rdp.scissor_o.ul_y), rdp.scissor_o.lr_y);
|
||||
uint32_t zi_width_in_dwords = rdp.ci_width >> 1;
|
||||
ul_x >>= 1;
|
||||
lr_x >>= 1;
|
||||
|
|
@ -2334,10 +2334,10 @@ static void rdp_fillrect()
|
|||
rdp.scissor.lr_y);
|
||||
|
||||
// KILL the floating point error with 0.01f
|
||||
wxInt32 s_ul_x = (uint32_t)min(max(ul_x * rdp.scale_x + rdp.offset_x + 0.01f, rdp.scissor.ul_x), rdp.scissor.lr_x);
|
||||
wxInt32 s_lr_x = (uint32_t)min(max(lr_x * rdp.scale_x + rdp.offset_x + 0.01f, rdp.scissor.ul_x), rdp.scissor.lr_x);
|
||||
wxInt32 s_ul_y = (uint32_t)min(max(ul_y * rdp.scale_y + rdp.offset_y + 0.01f, rdp.scissor.ul_y), rdp.scissor.lr_y);
|
||||
wxInt32 s_lr_y = (uint32_t)min(max(lr_y * rdp.scale_y + rdp.offset_y + 0.01f, rdp.scissor.ul_y), rdp.scissor.lr_y);
|
||||
wxInt32 s_ul_x = (uint32_t)minval(maxval(ul_x * rdp.scale_x + rdp.offset_x + 0.01f, rdp.scissor.ul_x), rdp.scissor.lr_x);
|
||||
wxInt32 s_lr_x = (uint32_t)minval(maxval(lr_x * rdp.scale_x + rdp.offset_x + 0.01f, rdp.scissor.ul_x), rdp.scissor.lr_x);
|
||||
wxInt32 s_ul_y = (uint32_t)minval(maxval(ul_y * rdp.scale_y + rdp.offset_y + 0.01f, rdp.scissor.ul_y), rdp.scissor.lr_y);
|
||||
wxInt32 s_lr_y = (uint32_t)minval(maxval(lr_y * rdp.scale_y + rdp.offset_y + 0.01f, rdp.scissor.ul_y), rdp.scissor.lr_y);
|
||||
|
||||
if (s_lr_x < 0) s_lr_x = 0;
|
||||
if (s_lr_y < 0) s_lr_y = 0;
|
||||
|
|
@ -2495,7 +2495,7 @@ static void rdp_setprimcolor()
|
|||
{
|
||||
rdp.prim_color = rdp.cmd1;
|
||||
rdp.prim_lodmin = (rdp.cmd0 >> 8) & 0xFF;
|
||||
rdp.prim_lodfrac = max(rdp.cmd0 & 0xFF, rdp.prim_lodmin);
|
||||
rdp.prim_lodfrac = maxval(rdp.cmd0 & 0xFF, rdp.prim_lodmin);
|
||||
rdp.update |= UPDATE_COMBINE;
|
||||
|
||||
FRDP("setprimcolor: %08lx, lodmin: %d, lodfrac: %d\n", rdp.cmd1, rdp.prim_lodmin,
|
||||
|
|
@ -2925,7 +2925,7 @@ static void rdp_setcolorimage()
|
|||
if (rdp.zimg == rdp.cimg)
|
||||
{
|
||||
rdp.zi_width = rdp.ci_width;
|
||||
// int zi_height = min((int)rdp.zi_width*3/4, (int)rdp.vi_height);
|
||||
// int zi_height = minval((int)rdp.zi_width*3/4, (int)rdp.vi_height);
|
||||
// rdp.zi_words = rdp.zi_width * zi_height;
|
||||
}
|
||||
uint32_t format = (rdp.cmd0 >> 21) & 0x7;
|
||||
|
|
@ -3202,10 +3202,10 @@ EXPORT void CALL FBWrite(uint32_t addr, uint32_t /*size*/)
|
|||
uint32_t shift_l = (a - rdp.cimg) >> 1;
|
||||
uint32_t shift_r = shift_l + 2;
|
||||
|
||||
d_ul_x = min(d_ul_x, shift_l%rdp.ci_width);
|
||||
d_ul_y = min(d_ul_y, shift_l / rdp.ci_width);
|
||||
d_lr_x = max(d_lr_x, shift_r%rdp.ci_width);
|
||||
d_lr_y = max(d_lr_y, shift_r / rdp.ci_width);
|
||||
d_ul_x = minval(d_ul_x, shift_l%rdp.ci_width);
|
||||
d_ul_y = minval(d_ul_y, shift_l / rdp.ci_width);
|
||||
d_lr_x = maxval(d_lr_x, shift_r%rdp.ci_width);
|
||||
d_lr_y = maxval(d_lr_y, shift_r / rdp.ci_width);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
|
|
|
|||
|
|
@ -839,11 +839,11 @@ extern const char *CIStatus[];
|
|||
* The only solution is to include <vector> first, before <windef.h> or
|
||||
* before defining the below macros (or just don't use <windows.h>).
|
||||
*/
|
||||
#ifndef max
|
||||
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
||||
#ifndef maxval
|
||||
#define maxval(a, b) (((a) > (b)) ? (a) : (b))
|
||||
#endif
|
||||
#ifndef min
|
||||
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
||||
#ifndef minval
|
||||
#define minval(a, b) (((a) < (b)) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
|
|
@ -907,7 +907,7 @@ __inline void CalculateFog (VERTEX *v)
|
|||
if (v->w < 0.0f)
|
||||
v->f = 0.0f;
|
||||
else
|
||||
v->f = min(255.0f, max(0.0f, v->z_w * rdp.fog_multiplier + rdp.fog_offset));
|
||||
v->f = minval(255.0f, maxval(0.0f, v->z_w * rdp.fog_multiplier + rdp.fog_offset));
|
||||
v->a = (uint8_t)v->f;
|
||||
}
|
||||
else
|
||||
|
|
|
|||
|
|
@ -262,8 +262,8 @@ void DrawDepthImage(const DRAWIMAGE & d)
|
|||
float scale_y_src = 1.0f / rdp.scale_y;
|
||||
int src_width = d.imageW;
|
||||
int src_height = d.imageH;
|
||||
int dst_width = min(int(src_width*scale_x_dst), (int)settings.scr_res_x);
|
||||
int dst_height = min(int(src_height*scale_y_dst), (int)settings.scr_res_y);
|
||||
int dst_width = minval(int(src_width*scale_x_dst), (int)settings.scr_res_x);
|
||||
int dst_height = minval(int(src_height*scale_y_dst), (int)settings.scr_res_y);
|
||||
uint16_t * src = (uint16_t*)(gfx.RDRAM + d.imagePtr);
|
||||
uint16_t * dst = new uint16_t[dst_width*dst_height];
|
||||
for (int y = 0; y < dst_height; y++)
|
||||
|
|
@ -447,7 +447,7 @@ void DrawImage(DRAWIMAGE & d)
|
|||
else if (d.scaleX == 1.0f && d.scaleY == 1.0f)
|
||||
grClipWindow(rdp.scissor.ul_x, rdp.scissor.ul_y, rdp.scissor.lr_x, rdp.scissor.lr_y);
|
||||
else
|
||||
grClipWindow(rdp.scissor.ul_x, rdp.scissor.ul_y, min(rdp.scissor.lr_x, (uint32_t)((d.frameX + d.imageW / d.scaleX + 0.5f)*rdp.scale_x)), min(rdp.scissor.lr_y, (uint32_t)((d.frameY + d.imageH / d.scaleY + 0.5f)*rdp.scale_y)));
|
||||
grClipWindow(rdp.scissor.ul_x, rdp.scissor.ul_y, minval(rdp.scissor.lr_x, (uint32_t)((d.frameX + d.imageW / d.scaleX + 0.5f)*rdp.scale_x)), minval(rdp.scissor.lr_y, (uint32_t)((d.frameY + d.imageH / d.scaleY + 0.5f)*rdp.scale_y)));
|
||||
rdp.update |= UPDATE_SCISSOR;
|
||||
|
||||
// Texture ()
|
||||
|
|
@ -486,7 +486,7 @@ void DrawImage(DRAWIMAGE & d)
|
|||
cur_u = min_256_u + 1;
|
||||
|
||||
// calculate intersection with this point
|
||||
nlr_v = min(min(cur_wrap_v*d.imageH, (cur_v << y_shift)), lr_v);
|
||||
nlr_v = minval(minval(cur_wrap_v*d.imageH, (cur_v << y_shift)), lr_v);
|
||||
nlr_y = my * nlr_v + by;
|
||||
|
||||
nul_u = ul_u;
|
||||
|
|
@ -498,7 +498,7 @@ void DrawImage(DRAWIMAGE & d)
|
|||
while (1)
|
||||
{
|
||||
// calculate intersection with this point
|
||||
nlr_u = min(min(cur_wrap_u*d.imageW, (cur_u << x_shift)), lr_u);
|
||||
nlr_u = minval(minval(cur_wrap_u*d.imageW, (cur_u << x_shift)), lr_u);
|
||||
nlr_x = mx * nlr_u + bx;
|
||||
|
||||
// ** Load the texture, constant portions have been set above
|
||||
|
|
@ -657,8 +657,8 @@ void DrawHiresImage(DRAWIMAGE & d, int screensize = FALSE)
|
|||
lr_u *= rdp.tbuff_tex->u_scale;
|
||||
ul_v *= rdp.tbuff_tex->v_scale;
|
||||
lr_v *= rdp.tbuff_tex->v_scale;
|
||||
ul_u = max(0.15f, ul_u);
|
||||
ul_v = max(0.15f, ul_v);
|
||||
ul_u = maxval(0.15f, ul_u);
|
||||
ul_v = maxval(0.15f, ul_v);
|
||||
if (lr_x > rdp.scissor.lr_x) lr_x = (float)rdp.scissor.lr_x;
|
||||
if (lr_y > rdp.scissor.lr_y) lr_y = (float)rdp.scissor.lr_y;
|
||||
}
|
||||
|
|
@ -796,11 +796,11 @@ static void draw_split_triangle(VERTEX **vtx)
|
|||
int index, i, j, min_256, max_256, cur_256, left_256, right_256;
|
||||
float percent;
|
||||
|
||||
min_256 = min((int)vtx[0]->u0, (int)vtx[1]->u0); // bah, don't put two mins on one line
|
||||
min_256 = min(min_256, (int)vtx[2]->u0) >> 8; // or it will be calculated twice
|
||||
min_256 = minval((int)vtx[0]->u0, (int)vtx[1]->u0); // bah, don't put two mins on one line
|
||||
min_256 = minval(min_256, (int)vtx[2]->u0) >> 8; // or it will be calculated twice
|
||||
|
||||
max_256 = max((int)vtx[0]->u0, (int)vtx[1]->u0); // not like it makes much difference
|
||||
max_256 = max(max_256, (int)vtx[2]->u0) >> 8; // anyway :P
|
||||
max_256 = maxval((int)vtx[0]->u0, (int)vtx[1]->u0); // not like it makes much difference
|
||||
max_256 = maxval(max_256, (int)vtx[2]->u0) >> 8; // anyway :P
|
||||
|
||||
for (cur_256 = min_256; cur_256 <= max_256; cur_256++)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -156,7 +156,7 @@ static void fb_rect()
|
|||
int diff = abs((int)rdp.frame_buffers[rdp.ci_count-1].width - width);
|
||||
if (diff < 4)
|
||||
{
|
||||
uint32_t lr_y = min(rdp.scissor_o.lr_y, (rdp.cmd0 & 0xFFF) >> 2);
|
||||
uint32_t lr_y = minval(rdp.scissor_o.lr_y, (rdp.cmd0 & 0xFFF) >> 2);
|
||||
if (rdp.frame_buffers[rdp.ci_count-1].height < lr_y)
|
||||
{
|
||||
FRDP("fb_rect. ul_x: %d, lr_x: %d, fb_height: %d -> %d\n", ul_x, lr_x, rdp.frame_buffers[rdp.ci_count-1].height, lr_y);
|
||||
|
|
@ -380,7 +380,7 @@ static void fb_setcolorimage()
|
|||
{
|
||||
if (rdp.cimg == rdp.main_ci) //switched to main fb again
|
||||
{
|
||||
cur_fb.height = max(cur_fb.height, rdp.frame_buffers[rdp.main_ci_index].height);
|
||||
cur_fb.height = maxval(cur_fb.height, rdp.frame_buffers[rdp.main_ci_index].height);
|
||||
rdp.main_ci_index = rdp.ci_count;
|
||||
rdp.main_ci_end = rdp.cimg + ((cur_fb.width * cur_fb.height) << cur_fb.size >> 1);
|
||||
cur_fb.status = ci_main;
|
||||
|
|
|
|||
Loading…
Reference in New Issue