float ldexpf(float value, int exp)
{
if(!finitef(value)||value==(float)0.0) return value;
value = scalbnf(value,exp);
if(!finitef(value)||value==(float)0.0) errno = ERANGE;
return value;
}
static inline void drawMesh(MODEL *psModel, int now, int mesh)
{
MESH *psMesh = &psModel->mesh[mesh];
assert(psMesh);
if (psMesh->frameArray)
{
FRAME *psFrame = &psMesh->frameArray[psMesh->currentFrame];
FRAME *nextFrame = psFrame;
double fraction = 1.0f / (psFrame->timeSlice * 1000) * (now - psMesh->lastChange); // until next frame
Vector3f vec;
glPushMatrix(); // save matrix state
assert(psMesh->currentFrame < psMesh->frames);
if (psMesh->currentFrame == psMesh->frames - 1)
{
nextFrame = &psMesh->frameArray[0]; // wrap around
}
else
{
nextFrame = &psMesh->frameArray[psMesh->currentFrame + 1];
}
// Try to avoid crap drivers from taking down the entire system
assert(finitef(psFrame->translation.x) && finitef(psFrame->translation.y) && finitef(psFrame->translation.z));
assert(psFrame->rotation.x >= -360.0f && psFrame->rotation.y >= -360.0f && psFrame->rotation.z >= -360.0f);
assert(psFrame->rotation.x <= 360.0f && psFrame->rotation.y <= 360.0f && psFrame->rotation.z <= 360.0f);
// Translate
interpolateVectors(psFrame->translation, nextFrame->translation, &vec, fraction);
glTranslatef(vec.x, vec.z, vec.y); // z and y flipped
// Rotate
interpolateVectors(psFrame->rotation, nextFrame->rotation, &vec, fraction);
glRotatef(vec.x, 1, 0, 0);
glRotatef(vec.z, 0, 1, 0); // z and y flipped again...
glRotatef(vec.y, 0, 0, 1);
// Morph
if (!psMesh->teamColours)
{
psMesh->currentTextureArray = psFrame->textureArray;
}
}
glTexCoordPointer(2, GL_FLOAT, 0, psMesh->textureArray[psMesh->currentTextureArray]);
glVertexPointer(3, GL_FLOAT, 0, psMesh->vertexArray);
glDrawElements(GL_TRIANGLES, psMesh->faces * 3, GL_UNSIGNED_INT, psMesh->indexArray);
if (psMesh->frameArray)
{
glPopMatrix(); // restore position for next mesh
}
}
float
hypotf(float x, float y) /* wrapper hypotf */
{
#ifdef _IEEE_LIBM
return __ieee754_hypotf(x,y);
#else
float z;
z = __ieee754_hypotf(x,y);
if(_LIB_VERSION == _IEEE_) return z;
if((!finitef(z))&&finitef(x)&&finitef(y))
/* hypot overflow */
return (float)__kernel_standard((double)x,(double)y,104);
else
return z;
#endif
}
float
sinhf(float x) /* wrapper sinhf */
{
#ifdef _IEEE_LIBM
return __ieee754_sinhf(x);
#else
float z;
z = __ieee754_sinhf(x);
if(_LIB_VERSION == _IEEE_) return z;
if(!finitef(z)&&finitef(x)) {
/* sinhf overflow */
return (float)__kernel_standard((double)x,(double)x,125);
} else
return z;
#endif
}
//------------------------------------------------------------------------------
float Cmath::hypotf( float x, float y ) // wrapper hypotf
{
float z;
struct fexception exc;
z = __ieee754_hypotf( x, y );
if( m_fdlib_version == _IEEE_ )
{
return z;
}
if( ( !finitef( z ) ) && finitef( x ) && finitef( y ) )
{
// hypotf(finite,finite) overflow
exc.type = EX_OVERFLOW;
exc.name = "hypotf";
exc.err = 0;
exc.arg1 = (double)x;
exc.arg2 = (double)y;
if( m_fdlib_version == _SVID_ )
{
exc.retval = Huge();
}
else
{
exc.retval = HUGE_VAL;
}
if( m_fdlib_version == _POSIX_ )
{
errno = ERANGE;
}
else if( !matherr( &exc ) )
{
errno = ERANGE;
}
if( exc.err != 0 )
{
errno = exc.err;
}
return (float)exc.retval;
}
else
{
return z;
}
}
void WeaponSystem::clusterObjects() {
try {
int j = 0;
weaponsGeodex.clear();
for(rWeapon* model : weapons) {
float px = model->getPosX();
float pz = model->getPosZ();
if (!finitef(px) || !finitef(pz)) {
//mUncluster.push_back(model);
} else {
weaponsGeodex.put(px, pz, model);
}
j++;
}
} catch (char* s) {
logger->error() << "Could not cluster weapons: " << s << "\n";
}
try {
int j = 0;
targetsGeodex.clear();
for(rTarget* model : targets) {
float px = model->getPosX();
float pz = model->getPosZ();
if (!finitef(px) || !finitef(pz)) {
//mUncluster.push_back(model);
} else {
targetsGeodex.put(px, pz, model);
}
j++;
}
} catch (char* s) {
logger->error() << "Could not cluster targets: " << s << "\n";
}
}
float
lgammaf_r(float x, int *signgamp) /* wrapper lgammaf_r */
{
#ifdef _IEEE_LIBM
return __ieee754_lgammaf_r(x,signgamp);
#else
float y;
y = __ieee754_lgammaf_r(x,signgamp);
if(_LIB_VERSION == _IEEE_) return y;
if(!finitef(y)&&finitef(x)) {
if(floorf(x)==x&&x<=(float)0.0)
/* lgamma pole */
return (float)__kernel_standard((double)x,(double)x,115);
else
/* lgamma overflow */
return (float)__kernel_standard((double)x,(double)x,114);
} else
return y;
#endif
}
float
gammaf(float x)
{
#ifdef _IEEE_LIBM
return __ieee754_lgammaf_r(x,&signgam);
#else
float y;
y = __ieee754_lgammaf_r(x,&signgam);
if(_LIB_VERSION == _IEEE_) return y;
if(!finitef(y)&&finitef(x)) {
if(floorf(x)==x&&x<=(float)0.0)
/* gammaf pole */
return (float)__kernel_standard((double)x,(double)x,141);
else
/* gammaf overflow */
return (float)__kernel_standard((double)x,(double)x,140);
} else
return y;
#endif
}
float scalbf(float x, float fn) /* wrapper scalbf */
#endif
{
#ifdef _IEEE_LIBM
return __ieee754_scalbf(x,fn);
#else
float z;
z = __ieee754_scalbf(x,fn);
if(_LIB_VERSION == _IEEE_) return z;
if(!(finitef(z)||isnanf(z))&&finitef(x)) {
/* scalbf overflow */
return (float)__kernel_standard((double)x,(double)fn,132);
}
if(z==(float)0.0&&z!=x) {
/* scalbf underflow */
return (float)__kernel_standard((double)x,(double)fn,133);
}
#ifndef _SCALB_INT
if(!finitef(fn)) errno = ERANGE;
#endif
return z;
#endif
}
int IsFinite(float x)
{
#ifdef _MSC_VER
return _finite(x);
#elif HAVE_DECL_FINITE
return finitef(x);
#elif HAVE_DECL_ISFINITE
return isfinitef(x);
#elif HAVE_IEEE_COMPARISONS
float y=x-x;
return (y==y?1:0);
#else
#error "IsFinite: Neither Microsoft's _isfinite, isfinite, or IEEE comparisons defined"
return 0;
#endif
}
_M_INL float __ieee754_scalbf(float x, float fn)
#endif
{
#ifdef _SCALB_INT
return scalbnf(x,fn);
#else
if (isnanf(x)||isnanf(fn)) return x*fn;
if (!finitef(fn)) {
if(fn>(float)0.0) return x*fn;
else return x/(-fn);
}
if (rintf(fn)!=fn) return (fn-fn)/(fn-fn);
if ( fn > (float)65000.0) return scalbnf(x, 65000);
if (-fn > (float)65000.0) return scalbnf(x,-65000);
return scalbnf(x,(int)fn);
#endif
}
int64_t emulate_f2l(float value)
{
if (finitef(value)) {
if (value >= J_LONG_MAX)
return J_LONG_MAX;
if (value <= J_LONG_MIN)
return J_LONG_MIN;
return value;
}
if (isnanf(value))
return 0;
if (copysignf(1.0, value) > 0)
return J_LONG_MAX;
return J_LONG_MIN;
}
float
expf(float x) /* wrapper expf */
{
#ifdef _IEEE_LIBM
return __ieee754_expf(x);
#else
float z;
z = __ieee754_expf(x);
if(_LIB_VERSION == _IEEE_) return z;
if(finitef(x)) {
if(x>o_threshold)
/* exp overflow */
return (float)__kernel_standard((double)x,(double)x,106);
else if(x<u_threshold)
/* exp underflow */
return (float)__kernel_standard((double)x,(double)x,107);
}
return z;
#endif
}
float
powf(float x, float y) /* wrapper powf */
{
#ifdef _IEEE_LIBM
return __ieee754_powf(x,y);
#else
float z;
z=__ieee754_powf(x,y);
if(_LIB_VERSION == _IEEE_|| isnanf(y)) return z;
if(isnanf(x)) {
if(y==(float)0.0)
/* powf(NaN,0.0) */
return (float)__kernel_standard((double)x,(double)y,142);
else
return z;
}
if(x==(float)0.0){
if(y==(float)0.0)
/* powf(0.0,0.0) */
return (float)__kernel_standard((double)x,(double)y,120);
if(finitef(y)&&y<(float)0.0)
/* powf(0.0,negative) */
return (float)__kernel_standard((double)x,(double)y,123);
return z;
}
if(!finitef(z)) {
if(finitef(x)&&finitef(y)) {
if(isnanf(z))
/* powf neg**non-int */
return (float)__kernel_standard((double)x,(double)y,124);
else
/* powf overflow */
return (float)__kernel_standard((double)x,(double)y,121);
}
}
if(z==(float)0.0&&finitef(x)&&finitef(y))
/* powf underflow */
return (float)__kernel_standard((double)x,(double)y,122);
return z;
#endif
}
int finite(double x)
{
return finitef((float) x);
}
TEST(math, finitef) {
ASSERT_TRUE(finitef(123.0f));
ASSERT_FALSE(finitef(HUGE_VALF));
}
//------------------------------------------------------------------------------
float Cmath::lgammaf( float x )
{
float y;
struct fexception exc;
y = __ieee754_lgammaf_r( x, &m_isigngam );
if( m_fdlib_version == _IEEE_ )
{
return y;
}
if( !finitef( y ) && finitef( x ) )
{
exc.name = "lgammaf";
exc.err = 0;
exc.arg1 = exc.arg2 = (double)x;
if( m_fdlib_version == _SVID_ )
{
exc.retval = Huge();
}
else
{
exc.retval = HUGE_VAL;
}
if( floorf( x ) == x && x <= (float)0.0 )
{
// lgammaf(-integer)
exc.type = EX_SING;
if( m_fdlib_version == _POSIX_ )
{
errno = EDOM;
}
else if( !matherr( &exc ) )
{
errno = EDOM;
}
}
else
{
// lgammaf(finite) overflow
exc.type = EX_OVERFLOW;
if( m_fdlib_version == _POSIX_ )
{
errno = ERANGE;
}
else if( !matherr( &exc ) )
{
errno = ERANGE;
}
}
if( exc.err != 0 )
{
errno = exc.err;
}
return (float)exc.retval;
}
else
{
return y;
}
}
//------------------------------------------------------------------------------
float Cmath::lgammaf_r( float x, int* signgamp )
{
float y;
struct fexception exc;
y = __ieee754_lgammaf_r( x, signgamp );
if( m_fdlib_version == _IEEE_ )
{
return y;
}
if( !finitef( y ) && finitef( x ) )
{
# ifndef HUGE_VAL
# define HUGE_VAL inf
double inf = 0.0;
set_high_word( inf, 0x7ff00000 ); // set inf to infinite
# endif
exc.name = "lgammaf";
exc.err = 0;
exc.arg1 = exc.arg2 = (double)x;
if( m_fdlib_version == _SVID_ )
{
exc.retval = Huge();
}
else
{
exc.retval = HUGE_VAL;
}
if( floorf( x ) == x && x <= (float)0.0 )
{
// lgammaf(-integer) or lgamma(0)
exc.type = EX_SING;
if( m_fdlib_version == _POSIX_ )
{
errno = EDOM;
}
else if( !matherr( &exc ) )
{
errno = EDOM;
}
}
else
{
// lgammaf(finite) overflow
exc.type = EX_OVERFLOW;
if( m_fdlib_version == _POSIX_ )
{
errno = ERANGE;
}
else if( !matherr( &exc ) )
{
errno = ERANGE;
}
}
if( exc.err != 0 )
{
errno = exc.err;
}
return (float)exc.retval;
}
else
{
return y;
}
}
