fmath.h

Go to the documentation of this file.

 
#ifndef __LIBDRAGON_FMATH_H
#define __LIBDRAGON_FMATH_H
 
#include <math.h>
#include <string.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define BITCAST_F2I(f) ({ int32_t i; memcpy(&i, &f, 4); i; })
 
#define BITCAST_I2F(i) ({ float f;   memcpy(&f, &i, 4); f; })
 
static inline float fm_truncf(float x) {
    /* Notice that trunc.w.s is also emitted by the compiler when casting a
     * float to int, but in this case we want a floating point result anyway,
     * so it's useless to go back and forth a GPR. */
    float yint, y;
    __asm ("trunc.w.s  %0,%1" : "=f"(yint) : "f"(x));
    __asm ("cvt.s.w  %0,%1" : "=f"(y) : "f"(yint));
    return y;
}
 
static inline float fm_ceilf(float x) {
    float yint, y;
    __asm ("ceil.w.s  %0,%1" : "=f"(yint) : "f"(x));
    __asm ("cvt.s.w  %0,%1" : "=f"(y) : "f"(yint));
    return y;
}
 
static inline float fm_floorf(float x) {
    float yint, y;
    __asm ("floor.w.s  %0,%1" : "=f"(yint) : "f"(x));
    __asm ("cvt.s.w  %0,%1" : "=f"(y) : "f"(yint));
    return y;
}
 
static inline float fm_fmodf(float x, float y) {
    return x - fm_truncf(x * (1.0f / y)) * y;
}
 
static inline float fm_wrapf(float x, float y) {
    return x - fm_floorf(x * (1.0f / y)) * y;
}
 
float fm_sinf(float x);
 
float fm_sinf_approx(float x, int approx);
 
float fm_cosf(float x);
 
void fm_sincosf(float x, float *sin, float *cos);
 
float fm_atan2f(float y, float x);
 
#ifdef LIBDRAGON_FAST_MATH
    #define truncf(x)     fm_truncf(x)
    #define floorf(x)     fm_floorf(x)
    #define ceilf(x)      fm_ceilf(x)
 
    // The following macros contain a special-case: when called with constant
    // arguments, they fall back to the standard math.h version. This allows
    // the compiler to compute an accurate result at compile time.
    // For instance, if we find `sinf(sqrtf(2.0f))` in the source code,
    // we expect that to be resolved at compile-time with the maximum accuracy,
    // so it's important to generate code that calls the standard C function
    // which is then intrinsified by the compiler.
    #define fmodf(x, y)     ((__builtin_constant_p(x) && __builtin_constant_p(y)) ? fmodf(x,y) : fm_fmodf(x,y))
    #define sinf(x)         (__builtin_constant_p(x) ? sinf(x) : fm_sinf(x))
    #define cosf(x)         (__builtin_constant_p(x) ? cosf(x) : fm_cosf(x))
    #define sincosf(x,s,c)  (__builtin_constant_p(x) ? sincosf(x,s,c) : fm_sincosf(x,s,c))
    #define atan2f(y, x)    ((__builtin_constant_p(x) && __builtin_constant_p(y)) ? atan2f(y, x) : fm_atan2f(y, x))
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif