Extras/CDTestFramework/Opcode/Ice/_IceTypes.h

   1 /*
   2  *      ICE / OPCODE - Optimized Collision Detection
   3  * http://www.codercorner.com/Opcode.htm
   4  *
   5  * Copyright (c) 2001-2008 Pierre Terdiman,  pierre@codercorner.com
   6
   7 This software is provided 'as-is', without any express or implied warranty.
   8 In no event will the authors be held liable for any damages arising from the use of this software.
   9 Permission is granted to anyone to use this software for any purpose,
  10 including commercial applications, and to alter it and redistribute it freely,
  11 subject to the following restrictions:
  12
  13 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  14 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  15 3. This notice may not be removed or altered from any source distribution.
  16 */
  17 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  18 /**
  19  *      Contains custom types.
  20  *      \file           IceTypes.h
  21  *      \author         Pierre Terdiman
  22  *      \date           April, 4, 2000
  23  */
  24 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  25
  26 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  27 // Include Guard
  28 #ifndef __ICETYPES_H__
  29 #define __ICETYPES_H__
  30
  31         #define USE_HANDLE_MANAGER
  32
  33         // Constants
  34         #define PI                                      3.1415926535897932384626433832795028841971693993751f    //!< PI
  35         #define HALFPI                          1.57079632679489661923f                                                                 //!< 0.5 * PI
  36         #define TWOPI                           6.28318530717958647692f                                                                 //!< 2.0 * PI
  37         #define INVPI                           0.31830988618379067154f                                                                 //!< 1.0 / PI
  38
  39         #define RADTODEG                        57.2957795130823208768f                                                                 //!< 180.0 / PI, convert radians to degrees
  40         #define DEGTORAD                        0.01745329251994329577f                                                                 //!< PI / 180.0, convert degrees to radians
  41
  42         #define EXP                                     2.71828182845904523536f                                                                 //!< e
  43         #define INVLOG2                         3.32192809488736234787f                                                                 //!< 1.0 / log10(2)
  44         #define LN2                                     0.693147180559945f                                                                              //!< ln(2)
  45         #define INVLN2                          1.44269504089f                                                                                  //!< 1.0f / ln(2)
  46
  47         #define INV3                            0.33333333333333333333f                                                                 //!< 1/3
  48         #define INV6                            0.16666666666666666666f                                                                 //!< 1/6
  49         #define INV7                            0.14285714285714285714f                                                                 //!< 1/7
  50         #define INV9                            0.11111111111111111111f                                                                 //!< 1/9
  51         #define INV255                          0.00392156862745098039f                                                                 //!< 1/255
  52
  53         #define SQRT2                           1.41421356237f                                                                                  //!< sqrt(2)
  54         #define INVSQRT2                        0.707106781188f                                                                                 //!< 1 / sqrt(2)
  55
  56         #define SQRT3                           1.73205080757f                                                                                  //!< sqrt(3)
  57         #define INVSQRT3                        0.577350269189f                                                                                 //!< 1 / sqrt(3)
  58
  59         #define null                            0                                                                                                               //!< our own NULL pointer
  60
  61         // Custom types used in ICE
  62         typedef signed char                     sbyte;          //!< sizeof(sbyte)      must be 1
  63         typedef unsigned char           ubyte;          //!< sizeof(ubyte)      must be 1
  64         typedef signed short            sword;          //!< sizeof(sword)      must be 2
  65         typedef unsigned short          uword;          //!< sizeof(uword)      must be 2
  66         typedef signed int                      sdword;         //!< sizeof(sdword)     must be 4
  67         typedef unsigned int            udword;         //!< sizeof(udword)     must be 4
  68         typedef signed __int64          sqword;         //!< sizeof(sqword)     must be 8
  69         typedef unsigned __int64        uqword;         //!< sizeof(uqword)     must be 8
  70         typedef float                           float32;        //!< sizeof(float32)    must be 4
  71         typedef double                          float64;        //!< sizeof(float64)    must be 4
  72
  73         ICE_COMPILE_TIME_ASSERT(sizeof(bool)==1);       // ...otherwise things might fail with VC++ 4.2 !
  74         ICE_COMPILE_TIME_ASSERT(sizeof(ubyte)==1);
  75         ICE_COMPILE_TIME_ASSERT(sizeof(sbyte)==1);
  76         ICE_COMPILE_TIME_ASSERT(sizeof(sword)==2);
  77         ICE_COMPILE_TIME_ASSERT(sizeof(uword)==2);
  78         ICE_COMPILE_TIME_ASSERT(sizeof(udword)==4);
  79         ICE_COMPILE_TIME_ASSERT(sizeof(sdword)==4);
  80         ICE_COMPILE_TIME_ASSERT(sizeof(uqword)==8);
  81         ICE_COMPILE_TIME_ASSERT(sizeof(sqword)==8);
  82
  83         //! TO BE DOCUMENTED
  84         #define DECLARE_ICE_HANDLE(name)        struct name##__ { int unused; }; typedef struct name##__ *name
  85
  86         typedef udword                          DynID;          //!< Dynamic identifier
  87 #ifdef USE_HANDLE_MANAGER
  88         typedef udword                          KID;            //!< Kernel ID
  89 //      DECLARE_ICE_HANDLE(KID);
  90 #else
  91         typedef uword                           KID;            //!< Kernel ID
  92 #endif
  93         typedef udword                          RTYPE;          //!< Relationship-type (!) between owners and references
  94         #define INVALID_ID                      0xffffffff      //!< Invalid dword ID (counterpart of null pointers)
  95 #ifdef USE_HANDLE_MANAGER
  96         #define INVALID_KID                     0xffffffff      //!< Invalid Kernel ID
  97 #else
  98         #define INVALID_KID                     0xffff          //!< Invalid Kernel ID
  99 #endif
 100         #define INVALID_NUMBER          0xDEADBEEF      //!< Standard junk value
 101
 102         // Define BOOL if needed
 103         #ifndef BOOL
 104         typedef int     BOOL;                                           //!< Another boolean type.
 105         #endif
 106
 107         //! Union of a float and a sdword
 108         typedef union {
 109                 float   f;                                                      //!< The float
 110                 sdword  d;                                                      //!< The integer
 111         }scell;
 112
 113         //! Union of a float and a udword
 114         typedef union {
 115                 float   f;                                                      //!< The float
 116                 udword  d;                                                      //!< The integer
 117         }ucell;
 118
 119         // Type ranges
 120         #define MAX_SBYTE                               0x7f                                            //!< max possible sbyte value
 121         #define MIN_SBYTE                               0x80                                            //!< min possible sbyte value
 122         #define MAX_UBYTE                               0xff                                            //!< max possible ubyte value
 123         #define MIN_UBYTE                               0x00                                            //!< min possible ubyte value
 124         #define MAX_SWORD                               0x7fff                                          //!< max possible sword value
 125         #define MIN_SWORD                               0x8000                                          //!< min possible sword value
 126         #define MAX_UWORD                               0xffff                                          //!< max possible uword value
 127         #define MIN_UWORD                               0x0000                                          //!< min possible uword value
 128         #define MAX_SDWORD                              0x7fffffff                                      //!< max possible sdword value
 129         #define MIN_SDWORD                              0x80000000                                      //!< min possible sdword value
 130         #define MAX_UDWORD                              0xffffffff                                      //!< max possible udword value
 131         #define MIN_UDWORD                              0x00000000                                      //!< min possible udword value
 132         #define MAX_FLOAT                               FLT_MAX                                         //!< max possible float value
 133         #define MIN_FLOAT                               (-FLT_MAX)                                      //!< min possible loat value
 134         #define IEEE_1_0                                0x3f800000                                      //!< integer representation of 1.0
 135         #define IEEE_255_0                              0x437f0000                                      //!< integer representation of 255.0
 136         #define IEEE_MAX_FLOAT                  0x7f7fffff                                      //!< integer representation of MAX_FLOAT
 137         #define IEEE_MIN_FLOAT                  0xff7fffff                                      //!< integer representation of MIN_FLOAT
 138         #define IEEE_UNDERFLOW_LIMIT    0x1a000000
 139
 140         #define ONE_OVER_RAND_MAX               (1.0f / float(RAND_MAX))        //!< Inverse of the max possible value returned by rand()
 141
 142         typedef int                                     (__stdcall* PROC)();                    //!< A standard procedure call.
 143         typedef bool                            (*ENUMERATION)(udword value, udword param, udword context);     //!< ICE standard enumeration call
 144         typedef void**                          VTABLE;                                                 //!< A V-Table.
 145
 146         #undef          MIN
 147         #undef          MAX
 148         #define         MIN(a, b)       ((a) < (b) ? (a) : (b))                 //!< Returns the min value between a and b
 149         #define         MAX(a, b)       ((a) > (b) ? (a) : (b))                 //!< Returns the max value between a and b
 150         #define         MAXMAX(a,b,c)   ((a) > (b) ? MAX (a,c) : MAX (b,c))     //!<    Returns the max value between a, b and c
 151
 152         template<class T>       inline_ const T&        TMin    (const T& a, const T& b)        { return b < a ? b : a; }
 153         template<class T>       inline_ const T&        TMax    (const T& a, const T& b)        { return a < b ? b : a; }
 154         template<class T>       inline_ void            TSetMin (T& a, const T& b)                      { if(a>b)       a = b;          }
 155         template<class T>       inline_ void            TSetMax (T& a, const T& b)                      { if(a<b)       a = b;          }
 156
 157         #define         SQR(x)                  ((x)*(x))                                               //!< Returns x square
 158         #define         CUBE(x)                 ((x)*(x)*(x))                                   //!< Returns x cube
 159
 160         #define         AND             &                                                                               //!< ...
 161         #define         OR              |                                                                               //!< ...
 162         #define         XOR             ^                                                                               //!< ...
 163
 164         #define         QUADRAT(x)              ((x)*(x))                                               //!< Returns x square
 165
 166 #ifdef _WIN32
 167 #   define srand48(x) srand((unsigned int) (x))
 168 #       define srandom(x) srand((unsigned int) (x))
 169 #       define random()   ((double) rand())
 170 #   define drand48()  ((double) (((double) rand()) / ((double) RAND_MAX)))
 171 #endif
 172
 173 #endif // __ICETYPES_H__