global.h

Go to the documentation of this file.

#ifndef LE_GLOBAL_H
#define LE_GLOBAL_H

/*****************************************************************************/
    #include <stdint.h>
    #include <stdlib.h>
    #include <stddef.h>
    typedef unsigned long long      LeHandle;                                               
    #define cmmax(a,b)              ((a)>(b)?(a):(b))                                       
    #define cmmin(a,b)              ((a)<(b)?(a):(b))                                       
    #define cmabs(a)                ((a)<0.0f?(-(a)):(a))                                   
    #define cmbound(v, vmin, vmax)  ((v)>(vmax)?(vmax):((v)<(vmin)?(vmin):(v)))             
    #define cmsgn(a)                ((a)<0.0f?-1.0f:1.0f)                                   
    #define cmthr(a, t)             ((a)<(-t)?-1.0f:((a)>(t)?1.0f:0.0f))                    
    #define cmmod(a, m)             (((a) % (m) + (m)) % (m))                               
    #define cmmodf(a, m)            (fmodf((fmodf((a), (m)) + (m)), (m)))                   
    #define randf()                 (((float) rand() / (float) (RAND_MAX >> 1)) - 1.0f)     
    #define d2r                     (const float) (M_PI / 180.0f)                           
    #define r2d                     (const float) (180.0f / M_PI)                           
/*****************************************************************************/

    namespace LeGlobal {
        void toLower(char * txt);                                                           
        void toUpper(char * txt);                                                           
        void getFileExtention(char * ext, const int extSize, const char * path);            
        void getFileName(char * name, const int nameSize, const char * path);               
        void getFileDirectory(char * dir, int dirSize, const char * path);                  
        int log2i32(int n);                                                                 
    };

/*****************************************************************************/
    #ifdef __MINGW32__
        #include <string.h>
        #include <malloc.h>
        #define _strdup strdup
    #elif defined(__GNUC__)
        #include <string.h>
        #define _strdup strdup
        #if defined(__APPLE__)
            extern "C" void * _aligned_malloc(size_t size, size_t alignment);
        #else
            #ifndef _aligned_malloc
                #define _aligned_malloc(s, a) aligned_alloc(a, s)
            #endif
        #endif
        #ifndef _aligned_free
            #define _aligned_free  free
        #endif
    #elif defined(_MSC_VER)
        #include <malloc.h>
        #ifndef alloca
            #define alloca(s) _malloca(s)
        #endif
    #endif

/*****************************************************************************/
    #if LE_USE_SIMD == 1 && LE_USE_SSE2 == 1
        void * operator new(size_t size) {
            return _aligned_malloc(size, 16);
        }
        void * operator new[](size_t size) {
            return _aligned_malloc(size, 16);
        }
        void operator delete(void * ptr) {
            _aligned_free(ptr);
        }
        void operator delete[](void * ptr) {
            _aligned_free(ptr);
        }
    #endif
    
/*****************************************************************************/
#ifdef _MSC_VER
    #include <intrin.h>
    extern "C" int __builtin_ffs(int x);

#elif defined (__WATCOMC__)
    extern "C" int __builtin_ffs(int x);
    
// Watcom C++ is so outdated that it does not
// come with floating point version of math.h
// functions
    extern "C" float copysignf(float x, float y);
    
    #define sinf(n)     ((float)std::sin(n))
    #define asinf(n)    ((float)std::asin(n))
    #define cosf(n)     ((float)std::cos(n))
    #define acosf(n)    ((float)std::acos(n))
    #define tanf(n)     ((float)std::tan(n))
    #define atanf(n)    ((float)std::atan(n))
    #define floorf(n)   ((float)std::floor(n))
    #define ceilf(n)    ((float)std::ceil(n))
    #define sqrtf(n)    ((float)std::sqrt(n))
    #define fabsf(n)    ((float)std::fabs(n))
    #define atan2f(n,m) ((float)std::atan2(n,m))
        
    #define M_PI        3.14159265358979323846

#elif defined (AMIGA)
    extern "C" float copysignf(float x, float y);
#endif

/*****************************************************************************/
#define FROM_LEU16(x) (x = ((uint8_t *) &(x))[0] + (((uint8_t *) &(x))[1] << 8))
#define FROM_LES16(x) FROM_LEU16(x)
#define FROM_LEU32(x) (x = ((uint8_t *) &x)[0] + (((uint8_t *) &x)[1] << 8) + (((uint8_t *) &x)[2] << 16) + (((uint8_t *) &x)[3] << 24))
#define FROM_LES32(x) FROM_LEU32(x)

#define TO_LEU16(x) (\
    ((uint8_t *) &(x))[0] = ((uint16_t) (x)) & 0xFF, \
    ((uint8_t *) &(x))[1] = ((uint16_t) (x)) >> 8 \
    )

#define TO_LES16(x) (\
    ((uint8_t *) &(x))[0] = ((int16_t) (x)) & 0xFF, \
    ((uint8_t *) &(x))[1] = ((int16_t) (x)) >> 8 \
    )
    
#define TO_LEU32(x) (\
    ((uint8_t *) &(x))[0] = ((uint32_t) (x)) & 0xFF, \
    ((uint8_t *) &(x))[1] = ((uint32_t) (x)) >> 8, \
    ((uint8_t *) &(x))[2] = ((uint32_t) (x)) >> 16, \
    ((uint8_t *) &(x))[3] = ((uint32_t) (x)) >> 24 \
    )

#define TO_LES32(x) (\
    ((uint8_t *) &(x))[0] = ((int32_t) (x)) & 0xFF, \
    ((uint8_t *) &(x))[1] = ((int32_t) (x)) >> 8, \
    ((uint8_t *) &(x))[2] = ((int32_t) (x)) >> 16, \
    ((uint8_t *) &(x))[3] = ((int32_t) (x)) >> 24 \
    )
#endif // LE_GLOBAL_H