sbgDefines.h

Go to the documentation of this file.

#ifndef __SBG_DEFINES_H__
#define __SBG_DEFINES_H__

//----------------------------------------------------------------------//
//- Global definitions                                                 -//
//----------------------------------------------------------------------//
#ifndef SBG_DISABLE
        #define SBG_DISABLE     (0)
#endif

#ifndef SBG_ENABLE
        #define SBG_ENABLE      (1)
#endif

#ifndef FALSE
    #define FALSE        (0)
#endif

#ifndef TRUE
    #define TRUE        (1)
#endif

#ifndef NULL
        #define NULL            (0)
#endif

#ifndef SBG_INVALID_HANDLE
        #define SBG_INVALID_HANDLE      (0x00000000u)
#endif

#ifndef SBG_NOT_FOUND
        #define SBG_NOT_FOUND           (0xFFFFFFFFu)
#endif

#ifndef SBG_UNDEFINED
        #define SBG_UNDEFINED           (0xFFFFFFFFu)
#endif

#ifndef SBG_ARRAY_SIZE
        #define SBG_ARRAY_SIZE(a)       (sizeof(a) / sizeof((a)[0]))
#endif

#ifndef __GNUC__
#ifndef __BASE_FILE__
        #define __BASE_FILE__ __FILE__
#endif
#endif

#ifdef __cplusplus
        #define SBG_DELETE(p)           if (p){delete (p); (p) = NULL;}
        #define SBG_DELETE_ARRAY(p)     if (p){delete[] (p); (p) = NULL;}
        #define SBG_FREE(p)                     if (p){free(p); (p) = NULL;}
        #define SBG_FREE_ARRAY(p)       if (p){free(p); (p) = NULL;}
#else
        #define SBG_DELETE                      if (p){free(p); (p) = NULL;}
        #define SBG_DELETE_ARRAY        if (p){free(p); (p) = NULL;}
        #define SBG_FREE(p)                     if (p){free(p); (p) = NULL;}
        #define SBG_FREE_ARRAY(p)       if (p){free(p); (p) = NULL;}
#endif

//----------------------------------------------------------------------//
//- Compiller definitions                                              -//
//----------------------------------------------------------------------//

#ifndef SBG_INLINE
        #if defined(_WIN32) || defined(WIN32)
                #define SBG_INLINE                      __inline
        #else
                #define SBG_INLINE          static inline
        #endif
#endif

#ifndef SBG_UNUSED_PARAMETER
        #define SBG_UNUSED_PARAMETER(x)         (void)(x)
#endif

//----------------------------------------------------------------------//
//- Macro used to defined packed structures                            -//
//----------------------------------------------------------------------//

#ifdef __GNUC__
        #define SBG_BEGIN_PACKED()
#elif defined(_MSC_VER)
        #define SBG_BEGIN_PACKED()      __pragma(pack(push, 1))
#else
        #error you must byte-align these structures with the appropriate compiler directives
#endif

#ifdef __GNUC__
        #define SBG_PACKED                      __attribute__((packed))
#elif defined(_MSC_VER)
        #define SBG_PACKED
#else
        #error you must byte-align these structures with the appropriate compiler directives
#endif

#ifdef __GNUC__
        #define SBG_END_PACKED()
#elif defined(_MSC_VER)
        #define SBG_END_PACKED()                __pragma(pack(pop))
#else
        #error you must byte-align these structures with the appropriate compiler directives
#endif

//----------------------------------------------------------------------//
//- Deprecation definitions                                                            -//
//----------------------------------------------------------------------//

#ifdef __GNUC__
        #define SBG_DEPRECATED(func) func __attribute__ ((deprecated))
#elif defined(_MSC_VER)
        #define SBG_DEPRECATED(func) __declspec(deprecated) func
#else
        //#warning "WARNING: You need to implement SBG_DEPRECATED for this compiler"
        #define SBG_DEPRECATED(func) func
#endif

#ifdef __GNUC__
        #define SBG_DEPRECATED_MACRO(func) __pragma(deprecated(func))
#elif defined(_MSC_VER)
#define SBG_DEPRECATED_MACRO(func) __pragma(deprecated(func))
#else
        //#warning "WARNING: You need to implement SBG_DEPRECATED_MACRO for this compiler"
        #define SBG_DEPRECATED_MACRO(func) func
#endif

//----------------------------------------------------------------------//
//- Basic maths definitions                                            -//
//----------------------------------------------------------------------//
#ifndef SBG_PI
        #define SBG_PI 3.14159265358979323846
#endif

#ifndef SBG_PI_F
        #define SBG_PI_F 3.14159265358979323846f
#endif

#ifndef sbgMax
        #define sbgMax(a,b)            (((a) > (b)) ? (a) : (b))
#endif

#ifndef sbgMin
        #define sbgMin(a,b)            (((a) < (b)) ? (a) : (b))
#endif

#ifndef sbgClamp
        #define sbgClamp(value, minValue, maxValue)            (((value) < (minValue))?(minValue): ((value) > (maxValue)?maxValue:value))
#endif

SBG_INLINE double sbgRadToDegD(double angle)
{
        return angle * 180.0 / SBG_PI;
}

SBG_INLINE double sbgDegToRadD(double angle)
{
        return angle * SBG_PI / 180.0;
}

SBG_INLINE float sbgRadToDegF(float angle)
{
        return angle * 180.0f / SBG_PI_F;
}

SBG_INLINE float sbgDegToRadF(float angle)
{
        return angle * SBG_PI_F / 180.0f;
}

#endif  /* __SBG_DEFINES_H__ */