xavi
/
pcsxr
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Change "valid" flag to multiple bit flags 

Validity of a pgxp value can now be set for any of four components using individual bit flags. This also allows the potential expansion of more flag data for each component.
This commit is contained in:
iCatButler 2016-07-04 11:48:00 +01:00
parent 03cfe9e6c2
commit 97105b26f2
7 changed files with 105 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
libpcsxcore/pgxp_cpu.c
View File

@ -49,7 +49,7 @@ void InvalidLoad(u32 addr, u32 code, u32 value)
p.count = value;
}
p.valid = 0;
p.flags = 0;
// invalidate register
CPU_reg[reg] = p;
@ -69,7 +69,7 @@ void InvalidStore(u32 addr, u32 code, u32 value)
if (pD)
p = *pD;
p.valid = 0;
p.flags = 0;
p.count = (reg * 1000) + value;
// invalidate memory
@ -128,7 +128,7 @@ void PGXP_CPU_ANDI(u32 instr, u32 rtVal, u32 rsVal)
break;
default:
// x is undefined, invalidate value
CPU_reg[rt(instr)].valid = 0;
CPU_reg[rt(instr)].flags = 0;
}
CPU_reg[rt(instr)].value = rtVal;
@ -142,7 +142,7 @@ void PGXP_CPU_ORI(u32 instr, u32 rtVal, u32 rsVal)
// Invalidate on non-zero values for now
if (imm(instr) != 0)
CPU_reg[rt(instr)].valid = 0;
CPU_reg[rt(instr)].flags = 0;
CPU_reg[rt(instr)].value = rtVal;
}
@ -155,7 +155,7 @@ void PGXP_CPU_XORI(u32 instr, u32 rtVal, u32 rsVal)
// Invalidate on non-zero values for now
if (imm(instr) != 0)
CPU_reg[rt(instr)].valid = 0;
CPU_reg[rt(instr)].flags = 0;
CPU_reg[rt(instr)].value = rtVal;
}
@ -210,7 +210,7 @@ void PGXP_CPU_ADD(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -221,7 +221,7 @@ void PGXP_CPU_ADD(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
ret.x += CPU_reg[rt(instr)].x;
ret.y += CPU_reg[rt(instr)].y;
ret.valid &= CPU_reg[rt(instr)].valid;
ret.halfFlags[0] &= CPU_reg[rt(instr)].halfFlags[0];
ret.gFlags |= CPU_reg[rt(instr)].gFlags;
ret.lFlags |= CPU_reg[rt(instr)].lFlags;
ret.hFlags |= CPU_reg[rt(instr)].hFlags;
@ -245,7 +245,7 @@ void PGXP_CPU_SUB(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -256,7 +256,7 @@ void PGXP_CPU_SUB(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
ret.x -= CPU_reg[rt(instr)].x;
ret.y -= CPU_reg[rt(instr)].y;
ret.valid &= CPU_reg[rt(instr)].valid;
ret.halfFlags[0] &= CPU_reg[rt(instr)].halfFlags[0];
ret.gFlags |= CPU_reg[rt(instr)].gFlags;
ret.lFlags |= CPU_reg[rt(instr)].lFlags;
ret.hFlags |= CPU_reg[rt(instr)].hFlags;
@ -282,7 +282,7 @@ void PGXP_CPU_AND(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -293,7 +293,7 @@ void PGXP_CPU_AND(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
valt.d = rtVal;
// CPU_reg[rd(instr)].valid = CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid;
ret.valid = 1;
ret.flags = VALID_01;
if (vald.w.l == 0)
{
@ -304,17 +304,18 @@ void PGXP_CPU_AND(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
{
ret.x = CPU_reg[rs(instr)].x;
ret.lFlags = CPU_reg[rs(instr)].lFlags;
ret.valid &= CPU_reg[rs(instr)].valid;
ret.compFlags[0] = CPU_reg[rs(instr)].compFlags[0];
}
else if (vald.w.l == valt.w.l)
{
ret.x = CPU_reg[rt(instr)].x;
ret.lFlags = CPU_reg[rt(instr)].lFlags;
ret.valid &= CPU_reg[rt(instr)].valid;
ret.compFlags[0] = CPU_reg[rt(instr)].compFlags[0];
}
else
{
ret.valid = 0;
ret.x = (float)vald.sw.l;
ret.compFlags[0] = VALID;
ret.lFlags = 0;
}
@ -327,23 +328,24 @@ void PGXP_CPU_AND(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
{
ret.y = CPU_reg[rs(instr)].y;
ret.hFlags = CPU_reg[rs(instr)].hFlags;
ret.valid &= CPU_reg[rs(instr)].valid;
ret.compFlags[1] &= CPU_reg[rs(instr)].compFlags[1];
}
else if (vald.w.h == valt.w.h)
{
ret.y = CPU_reg[rt(instr)].y;
ret.hFlags = CPU_reg[rt(instr)].hFlags;
ret.valid &= CPU_reg[rt(instr)].valid;
ret.compFlags[1] &= CPU_reg[rt(instr)].compFlags[1];
}
else
{
ret.valid = 0;
ret.y = (float)vald.sw.h;
ret.compFlags[1] = VALID;
ret.hFlags = 0;
}
// iCB Hack: Force validity if even one half is valid
if ((ret.hFlags & VALID_HALF) || (ret.lFlags & VALID_HALF))
ret.valid = 1;
//if ((ret.hFlags & VALID_HALF) || (ret.lFlags & VALID_HALF))
// ret.valid = 1;
// /iCB Hack
ret.value = rdVal;
@ -376,7 +378,7 @@ void PGXP_CPU_SLT(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -400,7 +402,7 @@ void PGXP_CPU_SLTU(u32 instr, u32 rdVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -425,7 +427,7 @@ void PGXP_CPU_MULT(u32 instr, u32 hiVal, u32 loVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -437,7 +439,7 @@ void PGXP_CPU_MULT(u32 instr, u32 hiVal, u32 loVal, u32 rsVal, u32 rtVal)
CPU_Hi.x = vs * vt;// CPU_reg[rs(instr)].y * CPU_reg[rt(instr)].y;
CPU_Lo.y = (CPU_Hi.x - ((s32)CPU_Hi.x)) * (float)(1 << 16);// CPU_reg[rs(instr)].x * CPU_reg[rt(instr)].x; // Get fractional part
CPU_Lo.valid = CPU_Hi.valid = CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid;
CPU_Lo.halfFlags[0] = CPU_Hi.halfFlags[0] = (CPU_reg[rs(instr)].halfFlags[0] & CPU_reg[rt(instr)].halfFlags[0]);
CPU_Lo.value = loVal;
CPU_Hi.value = hiVal;
@ -450,7 +452,7 @@ void PGXP_CPU_MULTU(u32 instr, u32 hiVal, u32 loVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -462,7 +464,7 @@ void PGXP_CPU_MULTU(u32 instr, u32 hiVal, u32 loVal, u32 rsVal, u32 rtVal)
CPU_Hi.x = vs * vt;// fabs(CPU_reg[rs(instr)].y) * fabs(CPU_reg[rt(instr)].y);
CPU_Lo.y = (CPU_Hi.x - ((s32)CPU_Hi.x)) * (float)(1 << 16);// fabs(CPU_reg[rs(instr)].x) * fabs(CPU_reg[rt(instr)].x); // Get fractional part
CPU_Lo.valid = CPU_Hi.valid = CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid;
CPU_Lo.halfFlags[0] = CPU_Hi.halfFlags[0] = (CPU_reg[rs(instr)].halfFlags[0] & CPU_reg[rt(instr)].halfFlags[0]);
CPU_Lo.value = loVal;
CPU_Hi.value = hiVal;
@ -476,7 +478,7 @@ void PGXP_CPU_DIV(u32 instr, u32 hiVal, u32 loVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
//// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -489,7 +491,7 @@ void PGXP_CPU_DIV(u32 instr, u32 hiVal, u32 loVal, u32 rsVal, u32 rtVal)
CPU_Hi.x = fmod(vs, vt);
CPU_Lo.x -= CPU_Hi.x;
CPU_Lo.valid = CPU_Hi.valid = CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid;
CPU_Lo.halfFlags[0] = CPU_Hi.halfFlags[0] = (CPU_reg[rs(instr)].halfFlags[0] & CPU_reg[rt(instr)].halfFlags[0]);
CPU_Lo.value = loVal;
CPU_Hi.value = hiVal;
@ -503,7 +505,7 @@ void PGXP_CPU_DIVU(u32 instr, u32 hiVal, u32 loVal, u32 rsVal, u32 rtVal)
Validate(&CPU_reg[rt(instr)], rtVal);
//// iCB: Only require one valid input
if (!(CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid) && (CPU_reg[rs(instr)].valid || CPU_reg[rt(instr)].valid))
if (((CPU_reg[rt(instr)].flags & VALID_01) != VALID_01) != ((CPU_reg[rs(instr)].flags & VALID_01) != VALID_01))
{
MakeValid(&CPU_reg[rs(instr)], rsVal);
MakeValid(&CPU_reg[rt(instr)], rtVal);
@ -516,7 +518,7 @@ void PGXP_CPU_DIVU(u32 instr, u32 hiVal, u32 loVal, u32 rsVal, u32 rtVal)
CPU_Hi.x = fmod(fabs(vs), fabs(vt));
CPU_Lo.x -= CPU_Hi.x;
CPU_Lo.valid = CPU_Hi.valid = CPU_reg[rs(instr)].valid && CPU_reg[rt(instr)].valid;
CPU_Lo.halfFlags[0] = CPU_Hi.halfFlags[0] = (CPU_reg[rs(instr)].halfFlags[0] & CPU_reg[rt(instr)].halfFlags[0]);
CPU_Lo.value = loVal;
CPU_Hi.value = hiVal;
@ -760,7 +762,7 @@ void PGXP_CPU_SWR(u32 instr, u32 rtVal, u32 addr)
void PGXP_CPU_SH(u32 instr, u16 rtVal, u32 addr)
{
// validate and copy half value
MaskValidate(&CPU_reg[rt(instr)], rtVal, 0xFFFF);
MaskValidate(&CPU_reg[rt(instr)], rtVal, 0xFFFF, VALID_0);
WriteMem16(&CPU_reg[rt(instr)], addr);
}

10
libpcsxcore/pgxp_debug.c
View File

@ -299,20 +299,20 @@ void PrintOperands(char* szBuffer, u32 instr, u32 flags, const char* szDelim, ps
if (pReg)
{
sprintf(szTempBuffer, "%s %s [%x(%d, %d) %x(%.2f, %.2f, %.2f)%x : %x] ", szPre, szOpdName,
sprintf(szTempBuffer, "%s %s [%x(%d, %d) %x(%.2f, %.2f, %.2f)%x : %x:%x:%x:%x] ", szPre, szOpdName,
psx_reg.d, psx_reg.sw.l, psx_reg.sw.h,
pReg->value, pReg->x, pReg->y, pReg->z, pReg->count, pReg->valid);
pReg->value, pReg->x, pReg->y, pReg->z, pReg->count, pReg->compFlags[0], pReg->compFlags[1], pReg->compFlags[2], pReg->compFlags[3]);
strcat(szBuffer, szTempBuffer);
}
else if(flag == fOp_Ad)
{
pReg = GetPtr(psx_reg.d);
if(pReg)
sprintf(szTempBuffer, "%s %s [%x(%d, %d) (%x) %x(%.2f, %.2f, %.2f)%x : %x] ", szPre, szOpdName,
sprintf(szTempBuffer, "%s %s [%x(%d, %d) (%x) %x(%.2f, %.2f, %.2f)%x : %x:%x:%x:%x] ", szPre, szOpdName,
psx_reg.d, psx_reg.sw.l, psx_reg.sw.h, PGXP_ConvertAddress(psx_reg.d),
pReg->value, pReg->x, pReg->y, pReg->z, pReg->count, pReg->valid);
pReg->value, pReg->x, pReg->y, pReg->z, pReg->count, pReg->compFlags[0], pReg->compFlags[1], pReg->compFlags[2], pReg->compFlags[3]);
else
sprintf(szTempBuffer, "%s %s [%x(%d, %d) INVALID_ADDRESS!] ", szPre, szOpdName,
sprintf(szTempBuffer, "%s %s [%x(%d, %d) (%x) INVALID_ADDRESS!] ", szPre, szOpdName,
psx_reg.d, psx_reg.sw.l, psx_reg.sw.h, PGXP_ConvertAddress(psx_reg.d));
strcat(szBuffer, szTempBuffer);
}

6
libpcsxcore/pgxp_gte.c
View File

@ -83,7 +83,7 @@ void PGXP_pushSXYZ2f(float _x, float _y, float _z, unsigned int _v)
SXY2.y = _y;
SXY2.z = Config.PGXP_Texture ? _z : 1.f;
SXY2.value = _v;
SXY2.valid = 1;
SXY2.flags = VALID_ALL;
SXY2.count = uCount++;
// cache value in GPU plugin
@ -94,7 +94,7 @@ void PGXP_pushSXYZ2f(float _x, float _y, float _z, unsigned int _v)
GPU_pgxpCacheVertex(0, 0, NULL);
#ifdef GTE_LOG
GTE_LOG("PGXP_PUSH (%f, %f) %u %u|", SXY2.x, SXY2.y, SXY2.valid, SXY2.count);
GTE_LOG("PGXP_PUSH (%f, %f) %u %u|", SXY2.x, SXY2.y, SXY2.flags, SXY2.count);
#endif
}
@ -179,7 +179,7 @@ void PGXP_RTPS(u32 _n, u32 _v)
int PGXP_NLCIP_valid()
{
if (SXY0.valid && SXY1.valid && SXY2.valid && Config.PGXP_GTE && (Config.PGXP_Mode > 0))
if (((SXY0.flags & SXY1.flags & SXY2.flags & VALID_01) == VALID_01) && Config.PGXP_GTE && (Config.PGXP_Mode > 0))
return 1;
return 0;
}

11
libpcsxcore/pgxp_mem.c
View File

@ -141,6 +141,7 @@ void ValidateAndCopyMem(PGXP_value* dest, u32 addr, u32 value)
void ValidateAndCopyMem16(PGXP_value* dest, u32 addr, u32 value)
{
u32 validMask = 0;
psx_value val, mask;
PGXP_value* pMem = GetPtr(addr);
if (pMem != NULL)
@ -151,15 +152,17 @@ void ValidateAndCopyMem16(PGXP_value* dest, u32 addr, u32 value)
{
val.w.h = value;
mask.w.h = 0xFFFF;
validMask = VALID_1;
}
else
{
val.w.l = value;
mask.w.l = 0xFFFF;
validMask = VALID_0;
}
// validate and copy whole value
MaskValidate(pMem, val.d, mask.d);
MaskValidate(pMem, val.d, mask.d, validMask);
*dest = *pMem;
// if high word then shift
@ -167,12 +170,14 @@ void ValidateAndCopyMem16(PGXP_value* dest, u32 addr, u32 value)
{
dest->x = dest->y;
dest->lFlags = dest->hFlags;
dest->compFlags[0] = dest->compFlags[1];
}
// truncate value
dest->y = 0.f;
dest->hFlags = 0;
dest->value = value;
dest->compFlags[1] = VALID; // iCB: High word is valid, just 0
return;
}
@ -200,16 +205,18 @@ void WriteMem16(PGXP_value* src, u32 addr)
{
dest->y = src->x;
dest->hFlags = src->lFlags;
dest->compFlags[1] = src->compFlags[0];
pVal->w.h = (u16)src->value;
}
else
{
dest->x = src->x;
dest->lFlags = src->lFlags;
dest->compFlags[0] = src->compFlags[0];
pVal->w.l = (u16)src->value;
}
dest->valid = dest->valid && src->valid;
//dest->valid = dest->valid && src->valid;
dest->gFlags |= src->gFlags; // inherit flags from both values (?)
}
}

10
libpcsxcore/pgxp_value.c
View File

@ -5,12 +5,12 @@ void MakeValid(PGXP_value *pV, u32 psxV)
{
psx_value psx;
psx.d = psxV;
if (!pV->valid)
if (VALID_01 != (pV->flags & VALID_01))
{
pV->x = psx.sw.l;
pV->y = psx.sw.h;
pV->z = 1.f;
pV->valid = 1;
pV->flags |= VALID_ALL;
pV->value = psx.d;
}
}
@ -18,11 +18,11 @@ void MakeValid(PGXP_value *pV, u32 psxV)
void Validate(PGXP_value *pV, u32 psxV)
{
// assume pV is not NULL
pV->valid = (pV->valid) && (pV->value == psxV);
pV->flags &= pV->value == psxV ? ALL : INV_VALID_ALL;
}
void MaskValidate(PGXP_value *pV, u32 psxV, u32 mask)
void MaskValidate(PGXP_value *pV, u32 psxV, u32 mask, u32 validMask)
{
// assume pV is not NULL
pV->valid = (pV->valid) && ((pV->value & mask) == (psxV & mask));
pV->flags &= ((pV->value & mask) == (psxV & mask)) ? ALL : (ALL ^ (validMask));
}

25
libpcsxcore/pgxp_value.h
View File

@ -51,7 +51,12 @@ typedef struct PGXP_value_Tag
float x;
float y;
float z;
unsigned int valid;
union
{
unsigned int flags;
unsigned char compFlags[4];
unsigned short halfFlags[2];
};
unsigned int count;
unsigned int value;
@ -76,12 +81,26 @@ typedef enum
VALID_HALF = (1 << 0)
} PGXP_half_flags;
//typedef enum
//{
#define NONE 0
#define ALL 0xFFFFFFFF
#define VALID 1
#define VALID_0 (VALID << 0)
#define VALID_1 (VALID << 8)
#define VALID_2 (VALID << 16)
#define VALID_3 (VALID << 24)
#define VALID_01 (VALID_0 | VALID_1)
#define VALID_ALL (VALID_0 | VALID_1 | VALID_2 | VALID_3)
#define INV_VALID_ALL (ALL ^ VALID_ALL)
//} PGXP_value_flags;
static const PGXP_value PGXP_value_invalid_address = { 0.f, 0.f, 0.f, 0, 0, 0, INVALID_ADDRESS, 0, 0 };
static const PGXP_value PGXP_value_zero = { 0.f, 0.f, 0.f, 0, 0, 1, 0, 0, 0 };
static const PGXP_value PGXP_value_zero = { 0.f, 0.f, 0.f, 0, 0, VALID_ALL, 0, 0, 0 };
void MakeValid(PGXP_value *pV, u32 psxV);
void Validate(PGXP_value *pV, u32 psxV);
void MaskValidate(PGXP_value *pV, u32 psxV, u32 mask);
void MaskValidate(PGXP_value *pV, u32 psxV, u32 mask, u32 validMask);
typedef union

37
plugins/peopsxgl/pgxp_gpu.c
View File

@ -36,12 +36,29 @@ typedef struct
float x;
float y;
float z;
unsigned int valid;
union
{
unsigned int flags;
unsigned char compFlags[4];
};
unsigned int count;
unsigned int value;
unsigned int flags;
unsigned int mFlags;
} PGXP_vertex;
#define NONE 0
#define ALL 0xFFFFFFFF
#define VALID 1
#define VALID_0 (VALID << 0)
#define VALID_1 (VALID << 8)
#define VALID_2 (VALID << 16)
#define VALID_3 (VALID << 24)
#define VALID_01 (VALID_0 | VALID_1)
#define VALID_012 (VALID_0 | VALID_1 | VALID_2)
#define VALID_ALL (VALID_0 | VALID_1 | VALID_2 | VALID_3)
#define INV_VALID_ALL (ALL ^ VALID_ALL)
unsigned int PGXP_tDebug = 0;
/////////////////////////////////
//// Blade_Arma's Vertex Cache (CatBlade?)
@ -113,13 +130,14 @@ void CALLBACK GPUpgxpCacheVertex(short sx, short sy, const unsigned char* _pVert
(fabsf(pOldVertex->y - pNewVertex->y) > 0.1f) ||
(fabsf(pOldVertex->z - pNewVertex->z) > 0.1f))
{
pOldVertex->valid = 5;
pOldVertex->mFlags = 5;
return;
}
}
// Write vertex into cache
*pOldVertex = *pNewVertex;
pOldVertex->mFlags = 1;
}
}
}
@ -269,7 +287,7 @@ int PGXP_GetVertices(unsigned int* addr, void* pOutput, int xOffs, int yOffs)
// Find any invalid vertices
for (unsigned i = 0; i < count; ++i)
{
if (!primStart[stride * i].valid)
if (!((primStart[stride * i].flags & VALID_012) == VALID_012))
invalidVert++;
}
}
@ -278,7 +296,7 @@ int PGXP_GetVertices(unsigned int* addr, void* pOutput, int xOffs, int yOffs)
for (unsigned i = 0; i < count; ++i)
{
if (primStart && primStart[stride * i].valid && (primStart[stride * i].value == *(unsigned int*)(&pPrimData[stride * i * 2])))
if (primStart && ((primStart[stride * i].flags & VALID_01) == VALID_01) && (primStart[stride * i].value == *(unsigned int*)(&pPrimData[stride * i * 2])))
{
pVertex[i].x = (primStart[stride * i].x + xOffs);
pVertex[i].y = (primStart[stride * i].y + yOffs);
@ -286,6 +304,9 @@ int PGXP_GetVertices(unsigned int* addr, void* pOutput, int xOffs, int yOffs)
pVertex[i].w = primStart[stride * i].z;
pVertex[i].PGXP_flag = 1;
if ((primStart[stride * i].flags & VALID_2) != VALID_2)
pVertex[i].PGXP_flag = 6;
// Log incorrect vertices
//if (PGXP_tDebug &&
// (fabs((float)pPrimData[stride * i * 2] - pVertex[i].x) > debug_tolerance) ||
@ -295,7 +316,7 @@ int PGXP_GetVertices(unsigned int* addr, void* pOutput, int xOffs, int yOffs)
else
{
// Default to low precision vertex data
if (primStart && primStart[stride * i].valid && primStart[stride * i].value != *(unsigned int*)(&pPrimData[stride * i * 2]))
if (primStart && ((primStart[stride * i].flags & VALID_01) == VALID_01) && primStart[stride * i].value != *(unsigned int*)(&pPrimData[stride * i * 2]))
pVertex[i].PGXP_flag = 6;
else
pVertex[i].PGXP_flag = 2;
@ -306,7 +327,7 @@ int PGXP_GetVertices(unsigned int* addr, void* pOutput, int xOffs, int yOffs)
{
if (IsSessionID(pCacheVert->count))
{
if (pCacheVert->valid == 1)
if (pCacheVert->mFlags == 1)
{
pVertex[i].x = (pCacheVert->x + xOffs);
pVertex[i].y = (pCacheVert->y + yOffs);
@ -316,7 +337,7 @@ int PGXP_GetVertices(unsigned int* addr, void* pOutput, int xOffs, int yOffs)
// reduce number of invalid vertices
invalidVert--;
}
else if(pCacheVert->valid > 1)
else if(pCacheVert->mFlags > 1)
pVertex[i].PGXP_flag = 4;
}
}