git.cworth.org Git - vogl/blob - src/voglcore/vogl_ryg_types.hpp

   1 // File: ryg_types.hpp\r
   2 #pragma once\r
   3 #ifndef __TP_TYPES_HPP__\r
   4 #define __TP_TYPES_HPP__\r
   5 \r
   6 #include <stdlib.h>\r
   7 #include <string.h>\r
   8 #include <assert.h>\r
   9 #include <math.h>\r
  10 \r
  11 #ifdef _MSC_VER                              // microsoft C++\r
  12 \r
  13 #define sCONFIG_NATIVEINT         int _w64                // sDInt: an int of the same size as a pointer\r
  14 #define sCONFIG_INT64             __int64                 // sS64, sU64: a 64 bit int\r
  15 \r
  16 #define sINLINE                   __forceinline           // use this to inline\r
  17 \r
  18 #endif\r
  19 \r
  20 #ifdef __GNUC__                             // GNU C++\r
  21 \r
  22 #define sCONFIG_NATIVEINT         int\r
  23 #define sCONFIG_INT64             long long\r
  24 \r
  25 #define sINLINE                   __inline__\r
  26 \r
  27 #endif\r
  28 \r
  29 /****************************************************************************/\r
  30 /***                                                                      ***/\r
  31 /***   Basic Types and Functions                                          ***/\r
  32 /***                                                                      ***/\r
  33 /****************************************************************************/\r
  34 \r
  35 typedef unsigned char             sU8;      // for packed arrays\r
  36 typedef unsigned short            sU16;     // for packed arrays\r
  37 typedef unsigned int              sU32;     // for packed arrays and bitfields\r
  38 typedef unsigned sCONFIG_INT64    sU64;     // use as needed\r
  39 typedef signed char               sS8;      // for packed arrays\r
  40 typedef short                     sS16;     // for packed arrays\r
  41 typedef int                       sS32;     // for packed arrays\r
  42 typedef signed sCONFIG_INT64      sS64;     // use as needed\r
  43 typedef float                     sF32;     // basic floatingpoint\r
  44 typedef double                    sF64;     // use as needed\r
  45 typedef int                       sInt;     // use this most!\r
  46 typedef signed sCONFIG_NATIVEINT  sDInt;    // type for pointer diff\r
  47 typedef bool                      sBool;    // use for boolean function results\r
  48 \r
  49 /****************************************************************************/\r
  50 \r
  51 #define sTRUE   true\r
  52 #define sFALSE  false\r
  53 \r
  54 /****************************************************************************/\r
  55 \r
  56 template <class Type> sINLINE Type sMin(Type a,Type b)              {return (a<b) ? a : b;}\r
  57 template <class Type> sINLINE Type sMax(Type a,Type b)              {return (a>b) ? a : b;}\r
  58 template <class Type> sINLINE Type sSign(Type a)                    {return (a==0) ? Type(0) : (a>0) ? Type(1) : Type(-1);}\r
  59 template <class Type> sINLINE Type sClamp(Type a,Type min,Type max) {return (a>=max) ? max : (a<=min) ? min : a;}\r
  60 template <class Type> sINLINE void sSwap(Type &a,Type &b)           {Type s; s=a; a=b; b=s;}\r
  61 template <class Type> sINLINE Type sAlign(Type a,sInt b)            {return (Type)((((sDInt)a)+b-1)&(~(b-1)));}\r
  62 \r
  63 template <class Type> sINLINE Type sSquare(Type a)                  {return a*a;}\r
  64 \r
  65 /****************************************************************************/\r
  66 \r
  67 #define sPI     3.1415926535897932384626433832795\r
  68 #define sPI2    6.28318530717958647692528676655901\r
  69 #define sPIF    3.1415926535897932384626433832795f\r
  70 #define sPI2F   6.28318530717958647692528676655901f\r
  71 #define sSQRT2  1.4142135623730950488016887242097\r
  72 #define sSQRT2F 1.4142135623730950488016887242097f\r
  73 \r
  74 sINLINE sInt sAbs(sInt i)                                  { return abs(i); }\r
  75 sINLINE void sSetMem(void *dd,sInt s,sInt c)               { memset(dd,s,c); }\r
  76 sINLINE void sCopyMem(void *dd,const void *ss,sInt c)      { memcpy(dd,ss,c); }\r
  77 sINLINE sInt sCmpMem(const void *dd,const void *ss,sInt c) { return (sInt)memcmp(dd,ss,c); }\r
  78 \r
  79 sINLINE sF64 sFATan(sF64 f)         { return atan(f); }\r
  80 sINLINE sF64 sFATan2(sF64 a,sF64 b) { return atan2(a,b); }\r
  81 sINLINE sF64 sFCos(sF64 f)          { return cos(f); }\r
  82 sINLINE sF64 sFAbs(sF64 f)          { return fabs(f); }\r
  83 sINLINE sF64 sFLog(sF64 f)          { return log(f); }\r
  84 sINLINE sF64 sFLog10(sF64 f)        { return log10(f); }\r
  85 sINLINE sF64 sFSin(sF64 f)          { return sin(f); }\r
  86 sINLINE sF64 sFSqrt(sF64 f)         { return sqrt(f); }\r
  87 sINLINE sF64 sFTan(sF64 f)          { return tan(f); }\r
  88 \r
  89 sINLINE sF64 sFACos(sF64 f)         { return acos(f); }\r
  90 sINLINE sF64 sFASin(sF64 f)         { return asin(f); }\r
  91 sINLINE sF64 sFCosH(sF64 f)         { return cosh(f); }\r
  92 sINLINE sF64 sFSinH(sF64 f)         { return sinh(f); }\r
  93 sINLINE sF64 sFTanH(sF64 f)         { return tanh(f); }\r
  94 \r
  95 sINLINE sF64 sFInvSqrt(sF64 f)      { return 1.0/sqrt(f); }\r
  96 \r
  97 sINLINE sF64 sFFloor(sF64 f)        { return floor(f); }\r
  98 \r
  99 sINLINE sF64 sFPow(sF64 a,sF64 b)   { return pow(a,b); }\r
 100 sINLINE sF64 sFMod(sF64 a,sF64 b)   { return fmod(a,b); }\r
 101 sINLINE sF64 sFExp(sF64 f)          { return exp(f); }\r
 102 \r
 103 /****************************************************************************/\r
 104 /***                                                                      ***/\r
 105 /***   Debugging                                                          ***/\r
 106 /***                                                                      ***/\r
 107 /****************************************************************************/\r
 108 \r
 109 #define sVERIFY(x)    {assert(x);}\r
 110 #define sVERIFYFALSE  {assert(false);}\r
 111 \r
 112 /****************************************************************************/\r
 113 \r
 114 #endif\r
 115 \r