mirror of
https://github.com/rehlds/rehlds.git
synced 2024-12-29 08:05:50 +03:00
More SSE optimizations.
This commit is contained in:
Andrey
parent
6df2bd1a2a
commit
591ee6b490
@ -263,14 +263,15 @@ float (*LittleFloat)(float l);
|
||||
|
||||
int LongSwap(int l)
|
||||
{
|
||||
byte b1, b2, b3, b4;
|
||||
/*byte b1, b2, b3, b4;
|
||||
|
||||
b1 = l & 0xFF;
|
||||
b2 = (l >> 8) & 0xFF;
|
||||
b3 = (l >> 16) & 0xFF;
|
||||
b4 = (l >> 24) & 0xFF;
|
||||
|
||||
return ((int)b1 << 24) + ((int)b2 << 16) + ((int)b3 << 8) + b4;
|
||||
return ((int)b1 << 24) + ((int)b2 << 16) + ((int)b3 << 8) + b4;*/
|
||||
return _byteswap_ulong(l);
|
||||
}
|
||||
|
||||
int LongNoSwap(int l)
|
||||
@ -280,12 +281,16 @@ int LongNoSwap(int l)
|
||||
|
||||
short ShortSwap(short l)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return _byteswap_ushort(l); // xchg
|
||||
#else
|
||||
byte b1, b2;
|
||||
|
||||
b1 = l & 0xFF;
|
||||
b2 = (l >> 8) & 0xFF;
|
||||
|
||||
return (b1 << 8) + b2;
|
||||
#endif
|
||||
}
|
||||
|
||||
short ShortNoSwap(short l)
|
||||
@ -295,7 +300,7 @@ short ShortNoSwap(short l)
|
||||
|
||||
float FloatSwap(float f)
|
||||
{
|
||||
union
|
||||
/*union
|
||||
{
|
||||
float f;
|
||||
byte b[4];
|
||||
@ -307,7 +312,9 @@ float FloatSwap(float f)
|
||||
dat2.b[2] = dat1.b[1];
|
||||
dat2.b[3] = dat1.b[0];
|
||||
|
||||
return dat2.f;
|
||||
return dat2.f;*/
|
||||
unsigned long u = _byteswap_ulong(*(unsigned long *)&f);
|
||||
return *(float *)&u;
|
||||
}
|
||||
|
||||
float FloatNoSwap(float f)
|
||||
@ -443,7 +450,7 @@ void MSG_WriteUsercmd(sizebuf_t *buf, usercmd_t *to, usercmd_t *from)
|
||||
{
|
||||
delta_t **ppdesc;
|
||||
|
||||
ppdesc = (delta_t **)DELTA_LookupRegistration("usercmd_t");
|
||||
ppdesc = DELTA_LookupRegistration("usercmd_t");
|
||||
MSG_StartBitWriting(buf);
|
||||
DELTA_WriteDelta((byte *)from, (byte *)to, 1, *ppdesc, 0);
|
||||
MSG_EndBitWriting(buf);
|
||||
|
||||
@ -37,6 +37,24 @@ vec3_t vec3_origin;
|
||||
//short int old_cw;
|
||||
//DLONG dlong;
|
||||
|
||||
// aligned vec4_t
|
||||
typedef ALIGN16 vec4_t avec4_t;
|
||||
|
||||
// conversion multiplier
|
||||
const avec4_t deg2rad =
|
||||
{
|
||||
M_PI / 180.f,
|
||||
M_PI / 180.f,
|
||||
M_PI / 180.f,
|
||||
M_PI / 180.f
|
||||
};
|
||||
|
||||
// save 4d xmm to 3d vector. we can't optimize many simple vector3 functions because saving back to 3d is slow.
|
||||
void xmm2vec(vec_t *v, const __m128 m)
|
||||
{
|
||||
_mm_store_ss(v, m);
|
||||
_mm_storel_pi((__m64*)(v + 1), _mm_shuffle_ps(m, m, _MM_SHUFFLE(3, 2, 2, 1)));
|
||||
}
|
||||
|
||||
/* <46ebf> ../engine/mathlib.c:14 */
|
||||
float anglemod(float a)
|
||||
@ -126,19 +144,6 @@ NOBODY int InvertMatrix(const float *m, float *out);
|
||||
// float *r3; // 161
|
||||
//}
|
||||
|
||||
#ifdef REHLDS_FIXES
|
||||
void SinCos(float radians, float *sine, float *cosine)
|
||||
{
|
||||
__asm
|
||||
{
|
||||
fld dword ptr [radians];
|
||||
fsincos;
|
||||
fstp dword ptr [cosine];
|
||||
fstp dword ptr [sine];
|
||||
}
|
||||
}
|
||||
#endif // REHLDS_FIXES
|
||||
|
||||
/* <47067> ../engine/mathlib.c:267 */
|
||||
void AngleVectors(const vec_t *angles, vec_t *forward, vec_t *right, vec_t *up)
|
||||
{
|
||||
@ -149,9 +154,16 @@ void AngleVectors(const vec_t *angles, vec_t *forward, vec_t *right, vec_t *up)
|
||||
#endif // SWDS
|
||||
|
||||
#ifdef REHLDS_FIXES
|
||||
SinCos(DEG2RAD(angles[YAW]), &sy, &cy);
|
||||
SinCos(DEG2RAD(angles[PITCH]), &sp, &cp);
|
||||
SinCos(DEG2RAD(angles[ROLL]), &sr, &cr);
|
||||
// convert to radians
|
||||
avec4_t rad_angles;
|
||||
_mm_store_ps(rad_angles, _mm_mul_ps(_mm_loadu_ps(angles), _mm_load_ps(deg2rad)));
|
||||
|
||||
sy = sin(rad_angles[YAW]);
|
||||
cy = cos(rad_angles[YAW]);
|
||||
sp = sin(rad_angles[PITCH]);
|
||||
cp = cos(rad_angles[PITCH]);
|
||||
sr = sin(rad_angles[ROLL]);
|
||||
cr = cos(rad_angles[ROLL]);
|
||||
#else
|
||||
float angle;
|
||||
angle = (float)(angles[YAW] * (M_PI * 2 / 360));
|
||||
@ -191,9 +203,16 @@ void AngleVectorsTranspose(const vec_t *angles, vec_t *forward, vec_t *right, ve
|
||||
float sr, sp, sy, cr, cp, cy;
|
||||
|
||||
#ifdef REHLDS_FIXES
|
||||
SinCos(DEG2RAD(angles[YAW]), &sy, &cy);
|
||||
SinCos(DEG2RAD(angles[PITCH]), &sp, &cp);
|
||||
SinCos(DEG2RAD(angles[ROLL]), &sr, &cr);
|
||||
// convert to radians
|
||||
avec4_t rad_angles;
|
||||
_mm_store_ps(rad_angles, _mm_mul_ps(_mm_loadu_ps(angles), _mm_load_ps(deg2rad)));
|
||||
|
||||
sy = sin(rad_angles[YAW]);
|
||||
cy = cos(rad_angles[YAW]);
|
||||
sp = sin(rad_angles[PITCH]);
|
||||
cp = cos(rad_angles[PITCH]);
|
||||
sr = sin(rad_angles[ROLL]);
|
||||
cr = cos(rad_angles[ROLL]);
|
||||
#else
|
||||
float angle;
|
||||
angle = (float)(angles[YAW] * (M_PI * 2 / 360));
|
||||
@ -233,9 +252,16 @@ void AngleMatrix(const vec_t *angles, float(*matrix)[4])
|
||||
float sr, sp, sy, cr, cp, cy;
|
||||
|
||||
#ifdef REHLDS_FIXES
|
||||
SinCos(DEG2RAD(angles[ROLL]), &sy, &cy);
|
||||
SinCos(DEG2RAD(angles[YAW]), &sp, &cp);
|
||||
SinCos(DEG2RAD(angles[PITCH]), &sr, &cr);
|
||||
// convert to radians
|
||||
avec4_t rad_angles;
|
||||
_mm_store_ps(rad_angles, _mm_mul_ps(_mm_loadu_ps(angles), _mm_load_ps(deg2rad)));
|
||||
|
||||
sy = sin(rad_angles[ROLL]);
|
||||
cy = cos(rad_angles[ROLL]);
|
||||
sp = sin(rad_angles[YAW]);
|
||||
cp = cos(rad_angles[YAW]);
|
||||
sr = sin(rad_angles[PITCH]);
|
||||
cr = cos(rad_angles[PITCH]);
|
||||
#else
|
||||
float angle;
|
||||
angle = (float)(angles[ROLL] * (M_PI * 2 / 360));
|
||||
@ -321,11 +347,11 @@ int VectorCompare(const vec_t *v1, const vec_t *v2)
|
||||
}
|
||||
|
||||
/* <47524> ../engine/mathlib.c:476 */
|
||||
void VectorMA(const vec_t *veca, float scale, const vec_t *vecb, vec_t *vecc)
|
||||
void VectorMA(const vec_t *veca, float scale, const vec_t *vecm, vec_t *out)
|
||||
{
|
||||
vecc[0] = scale * vecb[0] + veca[0];
|
||||
vecc[1] = scale * vecb[1] + veca[1];
|
||||
vecc[2] = scale * vecb[2] + veca[2];
|
||||
out[0] = scale * vecm[0] + veca[0];
|
||||
out[1] = scale * vecm[1] + veca[1];
|
||||
out[2] = scale * vecm[2] + veca[2];
|
||||
}
|
||||
|
||||
#ifndef REHLDS_FIXES
|
||||
@ -337,7 +363,6 @@ long double _DotProduct(const vec_t *v1, const vec_t *v2)
|
||||
#else // REHLDS_FIXES
|
||||
float _DotProduct(const vec_t *v1, const vec_t *v2)
|
||||
{
|
||||
#ifdef REHLDS_FIXES
|
||||
// _mm_loadu_ps - load xmm from unaligned address
|
||||
// _mm_cvtss_f32 - return low float value of xmm
|
||||
// _mm_dp_ps - dot product
|
||||
@ -345,7 +370,6 @@ float _DotProduct(const vec_t *v1, const vec_t *v2)
|
||||
// dpps isn't binary compatible with separate sse2 instructions (max difference is about 0.0002f, but usually < 0.00001f)
|
||||
if (cpuinfo.sse4_1)
|
||||
return _mm_cvtss_f32(_mm_dp_ps(_mm_loadu_ps(v1), _mm_loadu_ps(v2), 0x71));
|
||||
#endif // REHLDS_FIXES
|
||||
|
||||
return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
|
||||
}
|
||||
@ -372,9 +396,18 @@ NOBODY void _VectorCopy(vec_t *in, vec_t *out);
|
||||
/* <47679> ../engine/mathlib.c:510 */
|
||||
void CrossProduct(const vec_t *v1, const vec_t *v2, vec_t *cross)
|
||||
{
|
||||
#ifdef REHLDS_FIXES
|
||||
__m128 a = _mm_loadu_ps(v1), b = _mm_loadu_ps(v2);
|
||||
__m128 m = _mm_sub_ps( _mm_mul_ps(b, _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 0, 2, 1))),
|
||||
_mm_mul_ps(a, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 0, 2, 1)))
|
||||
);
|
||||
|
||||
xmm2vec(cross, _mm_shuffle_ps(m, m, _MM_SHUFFLE(3, 0, 2, 1)));
|
||||
#else // REHLDS_FIXES
|
||||
cross[0] = v2[2] * v1[1] - v1[2] * v2[1];
|
||||
cross[1] = v1[2] * v2[0] - v1[0] * v2[2];
|
||||
cross[2] = v1[0] * v2[1] - v2[0] * v1[1];
|
||||
#endif // REHLDS_FIXES
|
||||
}
|
||||
|
||||
/* <476d8> ../engine/mathlib.c:519 */
|
||||
@ -383,9 +416,7 @@ float Length(const vec_t *v)
|
||||
#ifdef REHLDS_FIXES
|
||||
// based on dot product
|
||||
if (cpuinfo.sse4_1)
|
||||
{
|
||||
return _mm_cvtss_f32(_mm_sqrt_ps(_mm_dp_ps(_mm_loadu_ps(v), _mm_loadu_ps(v), 0x71)));
|
||||
}
|
||||
return _mm_cvtss_f32(_mm_sqrt_ss(_mm_dp_ps(_mm_loadu_ps(v), _mm_loadu_ps(v), 0x71)));
|
||||
#endif // REHLDS_FIXES
|
||||
|
||||
float length;
|
||||
@ -398,6 +429,17 @@ float Length(const vec_t *v)
|
||||
return sqrt(length);
|
||||
}
|
||||
|
||||
float Length2D(const vec_t *v)
|
||||
{
|
||||
#ifdef REHLDS_FIXES
|
||||
// based on dot product
|
||||
if (cpuinfo.sse4_1)
|
||||
return _mm_cvtss_f32(_mm_sqrt_ss(_mm_dp_ps(_mm_loadu_ps(v), _mm_loadu_ps(v), 0x31))); // 0b00110001
|
||||
#endif // REHLDS_FIXES
|
||||
|
||||
return sqrt(v[0] * v[0] + v[1] * v[1]);
|
||||
}
|
||||
|
||||
/* <47722> ../engine/mathlib.c:532 */
|
||||
float VectorNormalize(vec3_t v)
|
||||
{
|
||||
@ -457,7 +499,7 @@ NOBODY void VectorMatrix(vec_t *forward, vec_t *right, vec_t *up);
|
||||
/* <4794e> ../engine/mathlib.c:597 */
|
||||
void VectorAngles(const vec_t *forward, vec_t *angles)
|
||||
{
|
||||
float tmp, yaw, pitch;
|
||||
float length, yaw, pitch;
|
||||
|
||||
if (forward[1] == 0 && forward[0] == 0)
|
||||
{
|
||||
@ -473,8 +515,13 @@ void VectorAngles(const vec_t *forward, vec_t *angles)
|
||||
if (yaw < 0)
|
||||
yaw += 360;
|
||||
|
||||
tmp = sqrt((double)(forward[0] * forward[0] + forward[1] * forward[1]));
|
||||
pitch = (atan2((double)forward[2], (double)tmp) * 180.0 / M_PI);
|
||||
#ifdef REHLDS_FIXES
|
||||
length = Length2D(forward);
|
||||
#else // REHLDS_FIXES
|
||||
length = sqrt((double)(forward[0] * forward[0] + forward[1] * forward[1]));
|
||||
#endif // REHLDS_FIXES
|
||||
|
||||
pitch = atan2((double)forward[2], (double)length) * 180.0 / M_PI;
|
||||
if (pitch < 0)
|
||||
pitch += 360;
|
||||
}
|
||||
|
||||
@ -70,7 +70,7 @@ NOBODY void NormalizeAngles(float *angles);
|
||||
NOBODY void InterpolateAngles(float *start, float *end, float *output, float frac);
|
||||
void VectorTransform(const vec_t *in1, float *in2, vec_t *out);
|
||||
int VectorCompare(const vec_t *v1, const vec_t *v2);
|
||||
void VectorMA(const vec_t *veca, float scale, const vec_t *vecb, vec_t *vecc);
|
||||
void VectorMA(const vec_t *veca, float scale, const vec_t *vecm, vec_t *out);
|
||||
#ifdef REHLDS_FIXES
|
||||
float _DotProduct(const vec_t *v1, const vec_t *v2); // with sse support
|
||||
#else // REHLDS_FIXES
|
||||
@ -81,6 +81,7 @@ void _VectorAdd(vec_t *veca, vec_t *vecb, vec_t *out);
|
||||
NOBODY void _VectorCopy(vec_t *in, vec_t *out);
|
||||
void CrossProduct(const vec_t *v1, const vec_t *v2, vec_t *cross);
|
||||
float Length(const vec_t *v);
|
||||
float Length2D(const vec_t *v);
|
||||
float VectorNormalize(vec_t *v);
|
||||
NOBODY void VectorInverse(vec_t *v);
|
||||
void VectorScale(const vec_t *in, float scale, vec_t *out);
|
||||
|
||||
@ -99,7 +99,7 @@ mleaf_t *Mod_PointInLeaf(vec_t *p, model_t *model)
|
||||
{
|
||||
plane = node->plane;
|
||||
if (plane->type >= 3u)
|
||||
d = plane->normal[2] * p[2] + plane->normal[1] * p[1] + plane->normal[0] * p[0] - plane->dist;
|
||||
d = _DotProduct(plane->normal, p) - plane->dist;
|
||||
else
|
||||
d = p[plane->type] - plane->dist;
|
||||
|
||||
@ -258,7 +258,7 @@ qboolean IsCZPlayerModel(uint32 crc, const char * filename)
|
||||
model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean trackCRC)
|
||||
{
|
||||
unsigned char *buf;
|
||||
char tmpName[260];
|
||||
char tmpName[MAX_PATH];
|
||||
int length;
|
||||
CRC32_t currentCRC;
|
||||
|
||||
@ -282,11 +282,11 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean trackCRC)
|
||||
while (*(p++) == '/')
|
||||
;
|
||||
|
||||
strncpy(tmpName, p, 259);
|
||||
tmpName[259] = 0;
|
||||
strncpy(tmpName, p, sizeof(tmpName) - 1);
|
||||
tmpName[sizeof(tmpName) - 1] = '\0';
|
||||
|
||||
strncpy(mod->name, tmpName, 63);
|
||||
mod->name[63] = 0;
|
||||
strncpy(mod->name, tmpName, sizeof(mod->name) - 1);
|
||||
mod->name[sizeof(mod->name) - 1] = '\0';
|
||||
}
|
||||
|
||||
buf = COM_LoadFileForMe(mod->name, &length);
|
||||
@ -383,7 +383,7 @@ void Mod_AdInit(void)
|
||||
{
|
||||
int i;
|
||||
char *s;
|
||||
static char filename[260];
|
||||
static char filename[MAX_PATH];
|
||||
|
||||
tested = 1;
|
||||
i = COM_CheckParm("-ad");
|
||||
@ -392,7 +392,7 @@ void Mod_AdInit(void)
|
||||
s = com_argv[i + 1];
|
||||
if (s && *s)
|
||||
{
|
||||
_snprintf(filename, 0x104u, "%s", s);
|
||||
_snprintf(filename, MAX_PATH, "%s", s);
|
||||
if (FS_FileSize(filename) > 0)
|
||||
{
|
||||
Sys_Error("Mod_Init(): reverse me");
|
||||
|
||||
@ -50,10 +50,10 @@ float PM_TraceModel(physent_t *pEnt, vec_t *start, vec_t *end, trace_t *trace)
|
||||
pmove->usehull = 2;
|
||||
pHull = PM_HullForBsp(pEnt, offset);
|
||||
pmove->usehull = saveHull;
|
||||
start_l[0] = *start - offset[0];
|
||||
start_l[0] = start[0] - offset[0];
|
||||
start_l[1] = start[1] - offset[1];
|
||||
start_l[2] = start[2] - offset[2];
|
||||
end_l[0] = *end - offset[0];
|
||||
end_l[0] = end[0] - offset[0];
|
||||
end_l[1] = end[1] - offset[1];
|
||||
end_l[2] = end[2] - offset[2];
|
||||
SV_RecursiveHullCheck(pHull, pHull->firstclipnode, 0.0, 1.0, start_l, end_l, trace);
|
||||
@ -127,14 +127,13 @@ int PM_HullPointContents(hull_t *hull, int num, vec_t *p)
|
||||
if (num < hull->firstclipnode || num > hull->lastclipnode)
|
||||
Sys_Error("PM_HullPointContents: bad node number");
|
||||
node = &hull->clipnodes[num];
|
||||
plane = &hull->planes[hull->clipnodes[num].planenum];
|
||||
plane = &hull->planes[node->planenum];
|
||||
|
||||
double tmpDist;
|
||||
if (plane->type >= 3)
|
||||
tmpDist = plane->normal[2] * p[2] + plane->normal[1] * p[1] + plane->normal[0] * *p;
|
||||
d = _DotProduct(p, plane->normal) - plane->dist;
|
||||
else
|
||||
tmpDist = p[plane->type];
|
||||
d = (float)(tmpDist - plane->dist);
|
||||
d = p[plane->type] - plane->dist;
|
||||
|
||||
if (d >= 0.0)
|
||||
num = node->children[0];
|
||||
else
|
||||
@ -331,13 +330,13 @@ int _PM_TestPlayerPosition(vec_t *pos, pmtrace_t *ptrace, int(*pfnIgnore)(physen
|
||||
test[2] = pos[2] - offset[2];
|
||||
if (pe->solid == 4 && (pe->angles[0] != 0.0 || pe->angles[1] != 0.0 || pe->angles[2] != 0.0))
|
||||
{
|
||||
vec3_t forward, right, up, temp;
|
||||
|
||||
vec3_t forward, right, up;
|
||||
AngleVectors(pe->angles, forward, right, up);
|
||||
temp[0] = test[0]; temp[1] = test[1]; temp[2] = test[2];
|
||||
test[0] = forward[2] * test[2] + forward[1] * test[1] + forward[0] * test[0];
|
||||
test[1] = -(right[0] * temp[0] + right[2] * test[2] + right[1] * test[1]);
|
||||
test[2] = up[1] * temp[1] + up[0] * temp[0] + up[2] * test[2];
|
||||
|
||||
vec3_t temp = {test[0], test[1], test[2]};
|
||||
test[0] = _DotProduct(forward, temp);
|
||||
test[1] = -_DotProduct(right, temp);
|
||||
test[2] = _DotProduct(up, temp);
|
||||
}
|
||||
if (numhulls != 1)
|
||||
{
|
||||
@ -480,18 +479,20 @@ pmtrace_t _PM_PlayerTrace(vec_t *start, vec_t *end, int traceFlags, int numphyse
|
||||
|
||||
if (pe->solid == SOLID_BSP && (pe->angles[0] != 0.0 || pe->angles[1] != 0.0 || pe->angles[2] != 0.0))
|
||||
{
|
||||
vec3_t temp, forward, right, up;
|
||||
rotated = true;
|
||||
vec3_t forward, right, up;
|
||||
AngleVectors(pe->angles, forward, right, up);
|
||||
temp[0] = start_l[0]; temp[1] = start_l[1]; temp[2] = start_l[2];
|
||||
start_l[0] = forward[2] * start_l[2] + forward[1] * start_l[1] + forward[0] * start_l[0];
|
||||
start_l[1] = -(right[0] * temp[0] + right[2] * start_l[2] + right[1] * start_l[1]);
|
||||
start_l[2] = up[1] * temp[1] + up[0] * temp[0] + up[2] * start_l[2];
|
||||
|
||||
temp[0] = end_l[0]; temp[1] = end_l[1]; temp[2] = end_l[2];
|
||||
end_l[0] = forward[2] * end_l[2] + forward[1] * end_l[1] + forward[0] * end_l[0];
|
||||
end_l[1] = -(right[0] * temp[0] + right[2] * end_l[2] + right[1] * end_l[1]);
|
||||
end_l[2] = up[1] * temp[1] + up[0] * temp[0] + up[2] * end_l[2];
|
||||
vec3_t temp_start = {start_l[0], start_l[1], start_l[2]};
|
||||
start_l[0] = _DotProduct(forward, temp_start);
|
||||
start_l[1] = -_DotProduct(right, temp_start);
|
||||
start_l[2] = _DotProduct(up, temp_start);
|
||||
|
||||
vec3_t temp_end = {end_l[0], end_l[1], end_l[2]};
|
||||
end_l[0] = _DotProduct(forward, temp_end);
|
||||
end_l[1] = -_DotProduct(right, temp_end);
|
||||
end_l[2] = _DotProduct(up, temp_end);
|
||||
|
||||
rotated = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -550,13 +551,13 @@ pmtrace_t _PM_PlayerTrace(vec_t *start, vec_t *end, int traceFlags, int numphyse
|
||||
{
|
||||
if (rotated)
|
||||
{
|
||||
vec3_t temp, forward, right, up;
|
||||
vec3_t forward, right, up;
|
||||
AngleVectorsTranspose(pe->angles, forward, right, up);
|
||||
|
||||
temp[0] = total.plane.normal[0]; temp[1] = total.plane.normal[1]; temp[2] = total.plane.normal[2];
|
||||
total.plane.normal[0] = forward[2] * total.plane.normal[2] + forward[1] * total.plane.normal[1] + forward[0] * total.plane.normal[0];
|
||||
total.plane.normal[1] = right[2] * total.plane.normal[2] + right[1] * total.plane.normal[1] + right[0] * temp[0];
|
||||
total.plane.normal[2] = up[2] * total.plane.normal[2] + up[1] * temp[1] + up[0] * temp[0];
|
||||
vec3_t temp = {total.plane.normal[0], total.plane.normal[1], total.plane.normal[2]};
|
||||
total.plane.normal[0] = _DotProduct(forward, temp);
|
||||
total.plane.normal[1] = _DotProduct(right, temp);
|
||||
total.plane.normal[2] = _DotProduct(up, temp);
|
||||
}
|
||||
total.endpos[0] = (end[0] - start[0]) * total.fraction + start[0];
|
||||
total.endpos[1] = (end[1] - start[1]) * total.fraction + start[1];
|
||||
@ -601,21 +602,13 @@ struct pmtrace_s *PM_TraceLine(float *start, float *end, int flags, int usehull,
|
||||
if (flags)
|
||||
{
|
||||
if (flags == 1)
|
||||
{
|
||||
tr = _PM_PlayerTrace(start, end, 0, pmove->numvisent, pmove->visents, ignore_pe, 0);
|
||||
pmove->usehull = oldhull;
|
||||
}
|
||||
else
|
||||
{
|
||||
pmove->usehull = oldhull;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
tr = _PM_PlayerTrace(start, end, 0, pmove->numphysent, pmove->physents, ignore_pe, 0);
|
||||
pmove->usehull = oldhull;
|
||||
}
|
||||
|
||||
pmove->usehull = oldhull;
|
||||
return &tr;
|
||||
}
|
||||
|
||||
@ -629,15 +622,13 @@ struct pmtrace_s *PM_TraceLineEx(float *start, float *end, int flags, int usehul
|
||||
pmove->usehull = usehull;
|
||||
if (flags)
|
||||
{
|
||||
tr = _PM_PlayerTrace(start, end, 0, pmove->numvisent, pmove->visents, -1, pfnIgnore);
|
||||
pmove->usehull = oldhull;
|
||||
|
||||
tr = _PM_PlayerTrace(start, end, 0, pmove->numvisent, pmove->visents, -1, pfnIgnore);
|
||||
}
|
||||
else
|
||||
{
|
||||
tr = PM_PlayerTraceEx(start, end, 0, pfnIgnore);
|
||||
pmove->usehull = oldhull;
|
||||
}
|
||||
pmove->usehull = oldhull;
|
||||
return &tr;
|
||||
}
|
||||
|
||||
@ -954,4 +945,4 @@ qboolean PM_RecursiveHullCheck(hull_t *hull, int num, float p1f, float p2f, cons
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif // REHLDS_OPT_PEDANTIC
|
||||
#endif // REHLDS_OPT_PEDANTIC
|
||||
@ -459,8 +459,8 @@ msurface_t *SurfaceAtPoint(model_t *pModel, mnode_t *node, vec_t *start, vec_t *
|
||||
return 0;
|
||||
|
||||
plane = node->plane;
|
||||
front = start[2] * plane->normal[2] + plane->normal[0] * start[0] + start[1] * plane->normal[1] - plane->dist;
|
||||
back = plane->normal[0] * end[0] + plane->normal[2] * end[2] + plane->normal[1] * end[1] - plane->dist;
|
||||
front = _DotProduct(start, plane->normal) - plane->dist;
|
||||
back = _DotProduct(end, plane->normal) - plane->dist;
|
||||
s = (front < 0.0f) ? 1 : 0;
|
||||
t = (back < 0.0f) ? 1 : 0;
|
||||
if (t == s)
|
||||
@ -481,8 +481,8 @@ msurface_t *SurfaceAtPoint(model_t *pModel, mnode_t *node, vec_t *start, vec_t *
|
||||
{
|
||||
surf = &pModel->surfaces[node->firstsurface + i];
|
||||
tex = surf->texinfo;
|
||||
ds = (int)(mid[2] * tex->vecs[0][2] + mid[1] * tex->vecs[0][1] + mid[0] * tex->vecs[0][0] + tex->vecs[0][3]);
|
||||
dt = (int)(mid[2] * tex->vecs[1][2] + mid[1] * tex->vecs[1][1] + mid[0] * tex->vecs[1][0] + tex->vecs[1][3]);
|
||||
ds = (int)_DotProduct(mid, tex->vecs[0]);
|
||||
dt = (int)_DotProduct(mid, tex->vecs[1]);
|
||||
if (ds >= surf->texturemins[0])
|
||||
{
|
||||
if (dt >= surf->texturemins[1])
|
||||
@ -532,14 +532,14 @@ const char *TraceTexture(edict_t *pTextureEntity, const float *v1, const float *
|
||||
AngleVectors(pTextureEntity->v.angles, forward, right, up);
|
||||
|
||||
temp[0] = start[0]; temp[1] = start[1]; temp[2] = start[2];
|
||||
start[0] = forward[2] * start[2] + forward[1] * start[1] + forward[0] * start[0];
|
||||
start[1] = -(right[0] * temp[0] + right[2] * start[2] + right[1] * start[1]);
|
||||
start[2] = up[1] * temp[1] + up[0] * temp[0] + up[2] * start[2];
|
||||
start[0] = _DotProduct(forward, temp);
|
||||
start[1] = -_DotProduct(right, temp);
|
||||
start[2] = _DotProduct(up, temp);
|
||||
|
||||
temp[0] = end[0]; temp[1] = end[1]; temp[2] = end[2];
|
||||
end[0] = forward[2] * end[2] + forward[1] * end[1] + forward[0] * end[0];
|
||||
end[1] = -(right[0] * temp[0] + right[2] * end[2] + right[1] * end[1]);
|
||||
end[2] = up[1] * temp[1] + up[0] * temp[0] + up[2] * end[2];
|
||||
end[0] = _DotProduct(forward, temp);
|
||||
end[1] = -_DotProduct(right, temp);
|
||||
end[2] = _DotProduct(up, temp);
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -1933,10 +1933,10 @@ edict_t *PF_CreateFakeClient_I(const char *netname)
|
||||
ent->v.pContainingEntity = ent;
|
||||
ent->v.flags = FL_FAKECLIENT | FL_CLIENT;
|
||||
|
||||
Info_SetValueForKey(fakeclient->userinfo, "name", netname, 256);
|
||||
Info_SetValueForKey(fakeclient->userinfo, "model", "gordon", 256);
|
||||
Info_SetValueForKey(fakeclient->userinfo, "topcolor", "1", 256);
|
||||
Info_SetValueForKey(fakeclient->userinfo, "bottomcolor", "1", 256);
|
||||
Info_SetValueForKey(fakeclient->userinfo, "name", netname, MAX_INFO_STRING);
|
||||
Info_SetValueForKey(fakeclient->userinfo, "model", "gordon", MAX_INFO_STRING);
|
||||
Info_SetValueForKey(fakeclient->userinfo, "topcolor", "1", MAX_INFO_STRING);
|
||||
Info_SetValueForKey(fakeclient->userinfo, "bottomcolor", "1", MAX_INFO_STRING);
|
||||
fakeclient->sendinfo = 1;
|
||||
SV_ExtractFromUserinfo(fakeclient);
|
||||
|
||||
|
||||
@ -193,7 +193,7 @@ int ClipVelocity(vec_t *in, vec_t *normal, vec_t *out, float overbounce)
|
||||
if (normal[2] == 0.0)
|
||||
blocked |= 2u;
|
||||
|
||||
float backoff = (in[0] * normal[0] + in[1] * normal[1] + normal[2] * in[2]) * overbounce;
|
||||
float backoff = _DotProduct(in, normal) * overbounce;
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
float tmp = normal[i] * backoff;
|
||||
@ -231,7 +231,7 @@ int SV_FlyMove(edict_t *ent, float time, trace_t *steptrace)
|
||||
|
||||
vec3_t end;
|
||||
for (int i = 0; i < 3; i++)
|
||||
end[i] = time * ent->v.velocity[i] + ent->v.origin[i];
|
||||
VectorMA(ent->v.origin, time, ent->v.velocity, end);
|
||||
|
||||
trace_t trace = SV_Move(ent->v.origin, ent->v.mins, ent->v.maxs, end, 0, ent, monsterClip);
|
||||
if (trace.allsolid)
|
||||
@ -314,7 +314,7 @@ int SV_FlyMove(edict_t *ent, float time, trace_t *steptrace)
|
||||
if (j == i)
|
||||
continue;
|
||||
|
||||
if (new_velocity[2] * planes[j][2] + new_velocity[0] * planes[j][0] + new_velocity[1] * planes[j][1] < 0.0f)
|
||||
if (_DotProduct(new_velocity, planes[j]) < 0.0f)
|
||||
break;
|
||||
}
|
||||
if (j == numplanes)
|
||||
@ -326,8 +326,8 @@ int SV_FlyMove(edict_t *ent, float time, trace_t *steptrace)
|
||||
return blocked;
|
||||
|
||||
vec3_t dir;
|
||||
CrossProduct((const vec_t *)planes, planes[1], dir);
|
||||
float vscale = dir[2] * ent->v.velocity[2] + dir[0] * ent->v.velocity[0] + dir[1] * ent->v.velocity[1];
|
||||
CrossProduct(planes[0], planes[1], dir);
|
||||
float vscale = _DotProduct(dir, ent->v.velocity);
|
||||
VectorScale(dir, vscale, ent->v.velocity);
|
||||
}
|
||||
else
|
||||
@ -337,9 +337,7 @@ int SV_FlyMove(edict_t *ent, float time, trace_t *steptrace)
|
||||
ent->v.velocity[0] = new_velocity[0];
|
||||
}
|
||||
|
||||
if (original_velocity[2] * ent->v.velocity[2]
|
||||
+ original_velocity[0] * ent->v.velocity[0]
|
||||
+ original_velocity[1] * ent->v.velocity[1] <= 0.0f)
|
||||
if (_DotProduct(original_velocity, ent->v.velocity) <= 0.0f)
|
||||
{
|
||||
ent->v.velocity[0] = vec3_origin[0];
|
||||
ent->v.velocity[1] = vec3_origin[1];
|
||||
@ -417,7 +415,7 @@ trace_t SV_PushEntity(edict_t *ent, vec_t *push)
|
||||
vec3_t end; // 518
|
||||
int moveType;
|
||||
|
||||
end[0] = ent->v.origin[0] + push[0];
|
||||
end[0] = push[0] + ent->v.origin[0];
|
||||
end[1] = push[1] + ent->v.origin[1];
|
||||
end[2] = push[2] + ent->v.origin[2];
|
||||
|
||||
@ -637,7 +635,7 @@ int SV_PushRotate(edict_t *pusher, float movetime)
|
||||
Sys_Error("Out of edicts in simulator!\n");
|
||||
|
||||
vec3_t start, end, push, move;
|
||||
float start_off2;
|
||||
|
||||
if (check->v.movetype == MOVETYPE_PUSHSTEP)
|
||||
{
|
||||
vec3_t org;
|
||||
@ -646,24 +644,23 @@ int SV_PushRotate(edict_t *pusher, float movetime)
|
||||
org[2] = (check->v.absmax[2] + check->v.absmin[2]) * 0.5f;
|
||||
start[0] = org[0] - pusher->v.origin[0];
|
||||
start[1] = org[1] - pusher->v.origin[1];
|
||||
start_off2 = org[2];
|
||||
start[2] = org[2] - pusher->v.origin[2];
|
||||
}
|
||||
else
|
||||
{
|
||||
start[0] = check->v.origin[0] - pusher->v.origin[0];
|
||||
start[1] = check->v.origin[1] - pusher->v.origin[1];
|
||||
start_off2 = check->v.origin[2];
|
||||
start[2] = check->v.origin[2] - pusher->v.origin[2];
|
||||
}
|
||||
|
||||
start[2] = start_off2 - pusher->v.origin[2];
|
||||
pusher->v.solid = SOLID_NOT;
|
||||
|
||||
move[0] = forward[2] * start[2] + forward[1] * start[1] + forward[0] * start[0];
|
||||
move[1] = -(right[2] * start[2] + right[1] * start[1] + right[0] * start[0]);
|
||||
move[2] = up[2] * start[2] + up[1] * start[1] + up[0] * start[0];
|
||||
end[0] = forwardNow[2] * move[2] + forwardNow[1] * move[1] + forwardNow[0] * move[0];
|
||||
end[1] = rightNow[2] * move[2] + rightNow[1] * move[1] + rightNow[0] * move[0];
|
||||
end[2] = upNow[2] * move[2] + upNow[1] * move[1] + upNow[0] * move[0];
|
||||
move[0] = _DotProduct(forward, start);
|
||||
move[1] = -_DotProduct(right, start);
|
||||
move[2] = _DotProduct(up, start);
|
||||
end[0] = _DotProduct(forwardNow, move);
|
||||
end[1] = _DotProduct(rightNow, move);
|
||||
end[2] = _DotProduct(upNow, move);
|
||||
push[0] = end[0] - start[0];
|
||||
push[1] = end[1] - start[1];
|
||||
push[2] = end[2] - start[2];
|
||||
@ -1113,12 +1110,13 @@ void SV_Physics_Toss(edict_t *ent)
|
||||
ent->v.groundentity = trace.ent;
|
||||
}
|
||||
|
||||
if (move[2] * move[2] + move[1] * move[1] + move[0] * move[0] >= 900.0f)
|
||||
if (_DotProduct(move, move) >= 900.0f)
|
||||
{
|
||||
if (ent->v.movetype == MOVETYPE_BOUNCE || ent->v.movetype == MOVETYPE_BOUNCEMISSILE)
|
||||
{
|
||||
VectorScale(ent->v.velocity, (float)((1.0 - trace.fraction) * host_frametime * 0.9f), move);
|
||||
VectorMA(move, (float)((1.0 - trace.fraction) * host_frametime * 0.9f), ent->v.basevelocity, move);
|
||||
float scale = (1.0 - trace.fraction) * host_frametime * 0.9f;
|
||||
VectorScale(ent->v.velocity, scale, move);
|
||||
VectorMA(move, scale, ent->v.basevelocity, move);
|
||||
SV_PushEntity(ent, move);
|
||||
SV_CheckWaterTransition(ent);
|
||||
return;
|
||||
@ -1154,10 +1152,10 @@ void PF_WaterMove(edict_t *pSelf)
|
||||
if (pSelf->v.health < 0.0)
|
||||
return;
|
||||
|
||||
drownlevel = (pSelf->v.deadflag) ? 1.0f : 3.0f;
|
||||
flags = pSelf->v.flags;
|
||||
drownlevel = pSelf->v.deadflag ? 1.0f : 3.0f;
|
||||
waterlevel = pSelf->v.waterlevel;
|
||||
watertype = pSelf->v.watertype;
|
||||
flags = pSelf->v.flags;
|
||||
if (!(flags & (FL_IMMUNE_WATER | FL_GODMODE)))
|
||||
{
|
||||
if (flags & FL_SWIM && (waterlevel < drownlevel)
|
||||
|
||||
@ -95,6 +95,7 @@
|
||||
#define STDCALL __stdcall
|
||||
#define HIDDEN
|
||||
#define NOINLINE __declspec(noinline)
|
||||
#define ALIGN16 __declspec(align(16))
|
||||
|
||||
//inline bool SOCKET_FIONBIO(SOCKET s, int m) { return (ioctlsocket(s, FIONBIO, (u_long*)&m) == 0); }
|
||||
//inline int SOCKET_MSGLEN(SOCKET s, u_long& r) { return ioctlsocket(s, FIONREAD, (u_long*)&r); }
|
||||
@ -129,6 +130,7 @@
|
||||
#define STDCALL __attribute__ ((stdcall))
|
||||
#define HIDDEN __attribute__((visibility("hidden")))
|
||||
#define NOINLINE __attribute__((noinline))
|
||||
#define ALIGN16 __attribute__((aligned(16)))
|
||||
|
||||
//inline bool SOCKET_FIONBIO(SOCKET s, int m) { return (ioctl(s, FIONBIO, (int*)&m) == 0); }
|
||||
//inline int SOCKET_MSGLEN(SOCKET s, u_long& r) { return ioctl(s, FIONREAD, (int*)&r); }
|
||||
|
||||
Loading…
Reference in New Issue
Block a user