0.4 Win-Beta0.4.0

1 files changed, 186 insertions, 184 deletions

diff --git a/LibOVR/Src/Kernel/OVR_Alg.h b/LibOVR/Src/Kernel/OVR_Alg.h
index e03cea0..00264b5 100644
--- a/LibOVR/Src/Kernel/OVR_Alg.h
+++ b/LibOVR/Src/Kernel/OVR_Alg.h
@@ -1,6 +1,6 @@
 /************************************************************************************
 
-PublicHeader:   OVR.h
+PublicHeader:   OVR_Kernel.h
 Filename    :   OVR_Alg.h
 Content     :   Simple general purpose algorithms: Sort, Binary Search, etc.
 Created     :   September 19, 2012
@@ -66,12 +66,12 @@ template <typename T> OVR_FORCE_INLINE T       Lerp(T a, T b, T f)
 // absolutelly the same as regular gmin/gmax.
 template <typename T>   OVR_FORCE_INLINE const T PMin(const T a, const T b)
 {
-    OVR_COMPILER_ASSERT(sizeof(T) == sizeof(UPInt));
+    OVR_COMPILER_ASSERT(sizeof(T) == sizeof(size_t));
     return (a < b) ? a : b;
 }
 template <typename T>   OVR_FORCE_INLINE const T PMax(const T a, const T b)
 {
-    OVR_COMPILER_ASSERT(sizeof(T) == sizeof(UPInt));
+    OVR_COMPILER_ASSERT(sizeof(T) == sizeof(size_t));
     return (b < a) ? a : b;
 }
 
@@ -99,7 +99,7 @@ template<class T> struct OperatorLess
 // The range is specified with start, end, where "end" is exclusive!
 // The comparison predicate must be specified.
 template<class Array, class Less> 
-void QuickSortSliced(Array& arr, UPInt start, UPInt end, Less less)
+void QuickSortSliced(Array& arr, size_t start, size_t end, Less less)
 {
     enum 
     {
@@ -108,15 +108,15 @@ void QuickSortSliced(Array& arr, UPInt start, UPInt end, Less less)
 
     if(end - start <  2) return;
 
-    SPInt  stack[80];
-    SPInt* top   = stack; 
-    SPInt  base  = (SPInt)start;
-    SPInt  limit = (SPInt)end;
+    intptr_t  stack[80];
+    intptr_t* top   = stack; 
+    intptr_t  base  = (intptr_t)start;
+    intptr_t  limit = (intptr_t)end;
 
     for(;;)
     {
-        SPInt len = limit - base;
-        SPInt i, j, pivot;
+        intptr_t len = limit - base;
+        intptr_t i, j, pivot;
 
         if(len > Threshold)
         {
@@ -201,7 +201,7 @@ void QuickSortSliced(Array& arr, UPInt start, UPInt end, Less less)
 // The range is specified with start, end, where "end" is exclusive!
 // The data type must have a defined "<" operator.
 template<class Array> 
-void QuickSortSliced(Array& arr, UPInt start, UPInt end)
+void QuickSortSliced(Array& arr, size_t start, size_t end)
 {
     typedef typename Array::ValueType ValueType;
     QuickSortSliced(arr, start, end, OperatorLess<ValueType>::Compare);
@@ -210,7 +210,7 @@ void QuickSortSliced(Array& arr, UPInt start, UPInt end)
 // Same as corresponding G_QuickSortSliced but with checking array limits to avoid
 // crash in the case of wrong comparator functor.
 template<class Array, class Less> 
-bool QuickSortSlicedSafe(Array& arr, UPInt start, UPInt end, Less less)
+bool QuickSortSlicedSafe(Array& arr, size_t start, size_t end, Less less)
 {
     enum 
     {
@@ -219,15 +219,15 @@ bool QuickSortSlicedSafe(Array& arr, UPInt start, UPInt end, Less less)
 
     if(end - start <  2) return true;
 
-    SPInt  stack[80];
-    SPInt* top   = stack; 
-    SPInt  base  = (SPInt)start;
-    SPInt  limit = (SPInt)end;
+    intptr_t  stack[80];
+    intptr_t* top   = stack; 
+    intptr_t  base  = (intptr_t)start;
+    intptr_t  limit = (intptr_t)end;
 
     for(;;)
     {
-        SPInt len = limit - base;
-        SPInt i, j, pivot;
+        intptr_t len = limit - base;
+        intptr_t i, j, pivot;
 
         if(len > Threshold)
         {
@@ -316,7 +316,7 @@ bool QuickSortSlicedSafe(Array& arr, UPInt start, UPInt end, Less less)
 }
 
 template<class Array> 
-bool QuickSortSlicedSafe(Array& arr, UPInt start, UPInt end)
+bool QuickSortSlicedSafe(Array& arr, size_t start, size_t end)
 {
     typedef typename Array::ValueType ValueType;
     return QuickSortSlicedSafe(arr, start, end, OperatorLess<ValueType>::Compare);
@@ -374,11 +374,11 @@ bool QuickSortSafe(Array& arr)
 // an array with all equal elements will remain "untouched", while 
 // Quick Sort will considerably shuffle the elements in this case.
 template<class Array, class Less> 
-void InsertionSortSliced(Array& arr, UPInt start, UPInt end, Less less)
+void InsertionSortSliced(Array& arr, size_t start, size_t end, Less less)
 {
-    UPInt j = start;
-    UPInt i = j + 1;
-    UPInt limit = end;
+    size_t j = start;
+    size_t i = j + 1;
+    size_t limit = end;
 
     for(; i < limit; j = i, i++)
     {
@@ -401,7 +401,7 @@ void InsertionSortSliced(Array& arr, UPInt start, UPInt end, Less less)
 // The range is specified with start, end, where "end" is exclusive!
 // The data type must have a defined "<" operator.
 template<class Array> 
-void InsertionSortSliced(Array& arr, UPInt start, UPInt end)
+void InsertionSortSliced(Array& arr, size_t start, size_t end)
 {
     typedef typename Array::ValueType ValueType;
     InsertionSortSliced(arr, start, end, OperatorLess<ValueType>::Compare);
@@ -442,14 +442,14 @@ void InsertionSort(Array& arr)
 template<class Array> 
 typename Array::ValueType& Median(Array& arr)
 {
-    UPInt count = arr.GetSize();
-    UPInt mid = (count - 1) / 2;
+    size_t count = arr.GetSize();
+    size_t mid = (count - 1) / 2;
     OVR_ASSERT(count > 0);
 
-	for (UPInt j = 0; j <= mid; j++)
+	for (size_t j = 0; j <= mid; j++)
     {
-		UPInt min = j;
-		for (UPInt k = j + 1; k < count; k++)
+		size_t min = j;
+		for (size_t k = j + 1; k < count; k++)
             if (arr[k] < arr[min]) 
                 min = k;
         Swap(arr[j], arr[min]);
@@ -461,12 +461,12 @@ typename Array::ValueType& Median(Array& arr)
 // ***** LowerBoundSliced
 //
 template<class Array, class Value, class Less>
-UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& val, Less less)
+size_t LowerBoundSliced(const Array& arr, size_t start, size_t end, const Value& val, Less less)
 {
-    SPInt first = (SPInt)start;
-    SPInt len   = (SPInt)(end - start);
-    SPInt half;
-    SPInt middle;
+    intptr_t first = (intptr_t)start;
+    intptr_t len   = (intptr_t)(end - start);
+    intptr_t half;
+    intptr_t middle;
     
     while(len > 0) 
     {
@@ -482,7 +482,7 @@ UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va
             len = half;
         }
     }
-    return (UPInt)first;
+    return (size_t)first;
 }
 
 
@@ -490,7 +490,7 @@ UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va
 // ***** LowerBoundSliced
 //
 template<class Array, class Value>
-UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& val)
+size_t LowerBoundSliced(const Array& arr, size_t start, size_t end, const Value& val)
 {
     return LowerBoundSliced(arr, start, end, val, OperatorLess<Value>::Compare);
 }
@@ -499,7 +499,7 @@ UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va
 // ***** LowerBoundSized
 //
 template<class Array, class Value>
-UPInt LowerBoundSized(const Array& arr, UPInt size, const Value& val)
+size_t LowerBoundSized(const Array& arr, size_t size, const Value& val)
 {
     return LowerBoundSliced(arr, 0, size, val, OperatorLess<Value>::Compare);
 }
@@ -508,7 +508,7 @@ UPInt LowerBoundSized(const Array& arr, UPInt size, const Value& val)
 // ***** LowerBound
 //
 template<class Array, class Value, class Less>
-UPInt LowerBound(const Array& arr, const Value& val, Less less)
+size_t LowerBound(const Array& arr, const Value& val, Less less)
 {
     return LowerBoundSliced(arr, 0, arr.GetSize(), val, less);
 }
@@ -518,7 +518,7 @@ UPInt LowerBound(const Array& arr, const Value& val, Less less)
 // ***** LowerBound
 //
 template<class Array, class Value>
-UPInt LowerBound(const Array& arr, const Value& val)
+size_t LowerBound(const Array& arr, const Value& val)
 {
     return LowerBoundSliced(arr, 0, arr.GetSize(), val, OperatorLess<Value>::Compare);
 }
@@ -529,12 +529,12 @@ UPInt LowerBound(const Array& arr, const Value& val)
 // ***** UpperBoundSliced
 //
 template<class Array, class Value, class Less>
-UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& val, Less less)
+size_t UpperBoundSliced(const Array& arr, size_t start, size_t end, const Value& val, Less less)
 {
-    SPInt first = (SPInt)start;
-    SPInt len   = (SPInt)(end - start);
-    SPInt half;
-    SPInt middle;
+    intptr_t first = (intptr_t)start;
+    intptr_t len   = (intptr_t)(end - start);
+    intptr_t half;
+    intptr_t middle;
     
     while(len > 0) 
     {
@@ -550,7 +550,7 @@ UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va
             len   = len - half - 1;
         }
     }
-    return (UPInt)first;
+    return (size_t)first;
 }
 
 
@@ -558,7 +558,7 @@ UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va
 // ***** UpperBoundSliced
 //
 template<class Array, class Value>
-UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& val)
+size_t UpperBoundSliced(const Array& arr, size_t start, size_t end, const Value& val)
 {
     return UpperBoundSliced(arr, start, end, val, OperatorLess<Value>::Compare);
 }
@@ -568,7 +568,7 @@ UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va
 // ***** UpperBoundSized
 //
 template<class Array, class Value>
-UPInt UpperBoundSized(const Array& arr, UPInt size, const Value& val)
+size_t UpperBoundSized(const Array& arr, size_t size, const Value& val)
 {
     return UpperBoundSliced(arr, 0, size, val, OperatorLess<Value>::Compare);
 }
@@ -578,7 +578,7 @@ UPInt UpperBoundSized(const Array& arr, UPInt size, const Value& val)
 // ***** UpperBound
 //
 template<class Array, class Value, class Less>
-UPInt UpperBound(const Array& arr, const Value& val, Less less)
+size_t UpperBound(const Array& arr, const Value& val, Less less)
 {
     return UpperBoundSliced(arr, 0, arr.GetSize(), val, less);
 }
@@ -588,7 +588,7 @@ UPInt UpperBound(const Array& arr, const Value& val, Less less)
 // ***** UpperBound
 //
 template<class Array, class Value>
-UPInt UpperBound(const Array& arr, const Value& val)
+size_t UpperBound(const Array& arr, const Value& val)
 {
     return UpperBoundSliced(arr, 0, arr.GetSize(), val, OperatorLess<Value>::Compare);
 }
@@ -599,8 +599,8 @@ UPInt UpperBound(const Array& arr, const Value& val)
 //
 template<class Array> void ReverseArray(Array& arr)
 {
-    SPInt from = 0;
-    SPInt to   = arr.GetSize() - 1;
+    intptr_t from = 0;
+    intptr_t to   = arr.GetSize() - 1;
     while(from < to)
     {
         Swap(arr[from], arr[to]);
@@ -615,7 +615,7 @@ template<class Array> void ReverseArray(Array& arr)
 template<class CDst, class CSrc> 
 void AppendArray(CDst& dst, const CSrc& src)
 {
-    UPInt i;
+    size_t i;
     for(i = 0; i < src.GetSize(); i++) 
         dst.PushBack(src[i]);
 }
@@ -630,13 +630,14 @@ template<class T> class ArrayAdaptor
 public:
     typedef T ValueType;
     ArrayAdaptor() : Data(0), Size(0) {}
-    ArrayAdaptor(T* ptr, UPInt size) : Data(ptr), Size(size) {}
-    UPInt GetSize() const { return Size; }
-    const T& operator [] (UPInt i) const { return Data[i]; }
-          T& operator [] (UPInt i)       { return Data[i]; }
+    ArrayAdaptor(T* ptr, size_t size) : Data(ptr), Size(size) {}
+    size_t GetSize() const { return Size; }
+	int GetSizeI() const { return (int)GetSize(); }
+    const T& operator [] (size_t i) const { return Data[i]; }
+          T& operator [] (size_t i)       { return Data[i]; }
 private:
     T*      Data;
-    UPInt   Size;
+    size_t  Size;
 };
 
 
@@ -650,24 +651,25 @@ template<class T> class ConstArrayAdaptor
 public:
     typedef T ValueType;
     ConstArrayAdaptor() : Data(0), Size(0) {}
-    ConstArrayAdaptor(const T* ptr, UPInt size) : Data(ptr), Size(size) {}
-    UPInt GetSize() const { return Size; }
-    const T& operator [] (UPInt i) const { return Data[i]; }
+    ConstArrayAdaptor(const T* ptr, size_t size) : Data(ptr), Size(size) {}
+    size_t GetSize() const { return Size; }
+	int GetSizeI() const { return (int)GetSize(); }
+	const T& operator [] (size_t i) const { return Data[i]; }
 private:
     const T* Data;
-    UPInt    Size;
+    size_t   Size;
 };
 
 
 
 //-----------------------------------------------------------------------------------
-extern const UByte UpperBitTable[256];
-extern const UByte LowerBitTable[256];
+extern const uint8_t UpperBitTable[256];
+extern const uint8_t LowerBitTable[256];
 
 
 
 //-----------------------------------------------------------------------------------
-inline UByte UpperBit(UPInt val)
+inline uint8_t UpperBit(size_t val)
 {
 #ifndef OVR_64BIT_POINTERS
 
@@ -712,7 +714,7 @@ inline UByte UpperBit(UPInt val)
 }
 
 //-----------------------------------------------------------------------------------
-inline UByte LowerBit(UPInt val)
+inline uint8_t LowerBit(size_t val)
 {
 #ifndef OVR_64BIT_POINTERS
 
@@ -765,18 +767,18 @@ class MemUtil
 public:
                                     
     // Memory compare
-    static int      Cmp  (const void* p1, const void* p2, UPInt byteCount)      { return memcmp(p1, p2, byteCount); }
-    static int      Cmp16(const void* p1, const void* p2, UPInt int16Count);
-    static int      Cmp32(const void* p1, const void* p2, UPInt int32Count);
-    static int      Cmp64(const void* p1, const void* p2, UPInt int64Count); 
+    static int      Cmp  (const void* p1, const void* p2, size_t byteCount)      { return memcmp(p1, p2, byteCount); }
+    static int      Cmp16(const void* p1, const void* p2, size_t int16Count);
+    static int      Cmp32(const void* p1, const void* p2, size_t int32Count);
+    static int      Cmp64(const void* p1, const void* p2, size_t int64Count); 
 };
 
 // ** Inline Implementation
 
-inline int MemUtil::Cmp16(const void* p1, const void* p2, UPInt int16Count)
+inline int MemUtil::Cmp16(const void* p1, const void* p2, size_t int16Count)
 {
-    SInt16*  pa  = (SInt16*)p1; 
-    SInt16*  pb  = (SInt16*)p2;
+    int16_t*  pa  = (int16_t*)p1; 
+    int16_t*  pb  = (int16_t*)p2;
     unsigned ic  = 0;
     if (int16Count == 0)
         return 0;
@@ -785,10 +787,10 @@ inline int MemUtil::Cmp16(const void* p1, const void* p2, UPInt int16Count)
             return 0;
     return pa[ic] > pb[ic] ? 1 : -1;
 }
-inline int MemUtil::Cmp32(const void* p1, const void* p2, UPInt int32Count)
+inline int MemUtil::Cmp32(const void* p1, const void* p2, size_t int32Count)
 {
-    SInt32*  pa  = (SInt32*)p1;
-    SInt32*  pb  = (SInt32*)p2;
+    int32_t*  pa  = (int32_t*)p1;
+    int32_t*  pb  = (int32_t*)p2;
     unsigned ic  = 0;
     if (int32Count == 0)
         return 0;
@@ -797,10 +799,10 @@ inline int MemUtil::Cmp32(const void* p1, const void* p2, UPInt int32Count)
             return 0;
     return pa[ic] > pb[ic] ? 1 : -1;
 }
-inline int MemUtil::Cmp64(const void* p1, const void* p2, UPInt int64Count)
+inline int MemUtil::Cmp64(const void* p1, const void* p2, size_t int64Count)
 {
-    SInt64*  pa  = (SInt64*)p1;
-    SInt64*  pb  = (SInt64*)p2;
+    int64_t*  pa  = (int64_t*)p1;
+    int64_t*  pb  = (int64_t*)p2;
     unsigned ic  = 0;
     if (int64Count == 0)
         return 0;
@@ -822,8 +824,8 @@ namespace ByteUtil {
     // Swap the byte order of a byte array
     inline void     SwapOrder(void* pv, int size)
     {
-        UByte*  pb = (UByte*)pv;
-        UByte   temp;
+        uint8_t*  pb = (uint8_t*)pv;
+        uint8_t temp;
         for (int i = 0; i < size>>1; i++)
         { 
             temp            = pb[size-1-i];
@@ -833,29 +835,29 @@ namespace ByteUtil {
     }
 
     // Swap the byte order of primitive types
-    inline UByte    SwapOrder(UByte v)      { return v; }
-    inline SByte    SwapOrder(SByte v)      { return v; }
-    inline UInt16   SwapOrder(UInt16 v)     { return UInt16(v>>8)|UInt16(v<<8); }
-    inline SInt16   SwapOrder(SInt16 v)     { return SInt16((UInt16(v)>>8)|(v<<8)); }
-    inline UInt32   SwapOrder(UInt32 v)     { return (v>>24)|((v&0x00FF0000)>>8)|((v&0x0000FF00)<<8)|(v<<24); }
-    inline SInt32   SwapOrder(SInt32 p)     { return (SInt32)SwapOrder(UInt32(p)); }
-    inline UInt64   SwapOrder(UInt64 v)
+    inline uint8_t  SwapOrder(uint8_t v)    { return v; }
+    inline int8_t   SwapOrder(int8_t v)     { return v; }
+    inline uint16_t SwapOrder(uint16_t v)   { return uint16_t(v>>8)|uint16_t(v<<8); }
+    inline int16_t  SwapOrder(int16_t v)    { return int16_t((uint16_t(v)>>8)|(v<<8)); }
+    inline uint32_t SwapOrder(uint32_t v)   { return (v>>24)|((v&0x00FF0000)>>8)|((v&0x0000FF00)<<8)|(v<<24); }
+    inline int32_t  SwapOrder(int32_t p)    { return (int32_t)SwapOrder(uint32_t(p)); }
+    inline uint64_t SwapOrder(uint64_t v)
     { 
         return   (v>>56) |
-                 ((v&UInt64(0x00FF000000000000ULL))>>40) |
-                 ((v&UInt64(0x0000FF0000000000ULL))>>24) |
-                 ((v&UInt64(0x000000FF00000000ULL))>>8)  |
-                 ((v&UInt64(0x00000000FF000000ULL))<<8)  |
-                 ((v&UInt64(0x0000000000FF0000ULL))<<24) |
-                 ((v&UInt64(0x000000000000FF00ULL))<<40) |
+                 ((v&uint64_t(0x00FF000000000000ULL))>>40) |
+                 ((v&uint64_t(0x0000FF0000000000ULL))>>24) |
+                 ((v&uint64_t(0x000000FF00000000ULL))>>8)  |
+                 ((v&uint64_t(0x00000000FF000000ULL))<<8)  |
+                 ((v&uint64_t(0x0000000000FF0000ULL))<<24) |
+                 ((v&uint64_t(0x000000000000FF00ULL))<<40) |
                  (v<<56); 
     }
-    inline SInt64   SwapOrder(SInt64 v)     { return (SInt64)SwapOrder(UInt64(v)); }
+    inline int64_t  SwapOrder(int64_t v)     { return (int64_t)SwapOrder(uint64_t(v)); }
     inline float    SwapOrder(float p)      
     { 
         union {
             float p;
-            UInt32 v;
+            uint32_t v;
         } u;
         u.p = p;
         u.v = SwapOrder(u.v);
@@ -866,7 +868,7 @@ namespace ByteUtil {
     { 
         union {
             double p;
-            UInt64 v;
+            uint64_t v;
         } u;
         u.p = p;
         u.v = SwapOrder(u.v);
@@ -877,99 +879,99 @@ namespace ByteUtil {
 
 #if (OVR_BYTE_ORDER == OVR_LITTLE_ENDIAN)
     // Little Endian to System (LE)
-    inline UByte    LEToSystem(UByte  v)    { return v; }
-    inline SByte    LEToSystem(SByte  v)    { return v; }
-    inline UInt16   LEToSystem(UInt16 v)    { return v; }
-    inline SInt16   LEToSystem(SInt16 v)    { return v; }
-    inline UInt32   LEToSystem(UInt32 v)    { return v; }
-    inline SInt32   LEToSystem(SInt32 v)    { return v; }
-    inline UInt64   LEToSystem(UInt64 v)    { return v; }
-    inline SInt64   LEToSystem(SInt64 v)    { return v; }
+    inline uint8_t  LEToSystem(uint8_t v)   { return v; }
+    inline int8_t   LEToSystem(int8_t v)    { return v; }
+    inline uint16_t LEToSystem(uint16_t v)  { return v; }
+    inline int16_t  LEToSystem(int16_t v)   { return v; }
+    inline uint32_t LEToSystem(uint32_t v)  { return v; }
+    inline int32_t  LEToSystem(int32_t v)   { return v; }
+    inline uint64_t LEToSystem(uint64_t v)  { return v; }
+    inline int64_t  LEToSystem(int64_t v)    { return v; }
     inline float    LEToSystem(float  v)    { return v; }
     inline double   LEToSystem(double v)    { return v; }
 
     // Big Endian to System (LE)
-    inline UByte    BEToSystem(UByte  v)    { return SwapOrder(v); }
-    inline SByte    BEToSystem(SByte  v)    { return SwapOrder(v); }
-    inline UInt16   BEToSystem(UInt16 v)    { return SwapOrder(v); }
-    inline SInt16   BEToSystem(SInt16 v)    { return SwapOrder(v); }
-    inline UInt32   BEToSystem(UInt32 v)    { return SwapOrder(v); }
-    inline SInt32   BEToSystem(SInt32 v)    { return SwapOrder(v); }
-    inline UInt64   BEToSystem(UInt64 v)    { return SwapOrder(v); }
-    inline SInt64   BEToSystem(SInt64 v)    { return SwapOrder(v); }
+    inline uint8_t  BEToSystem(uint8_t v)   { return SwapOrder(v); }
+    inline int8_t   BEToSystem(int8_t v)    { return SwapOrder(v); }
+    inline uint16_t BEToSystem(uint16_t v)  { return SwapOrder(v); }
+    inline int16_t  BEToSystem(int16_t v)   { return SwapOrder(v); }
+    inline uint32_t BEToSystem(uint32_t v)  { return SwapOrder(v); }
+    inline int32_t  BEToSystem(int32_t v)   { return SwapOrder(v); }
+    inline uint64_t BEToSystem(uint64_t v)  { return SwapOrder(v); }
+    inline int64_t  BEToSystem(int64_t v)    { return SwapOrder(v); }
     inline float    BEToSystem(float  v)    { return SwapOrder(v); }
     inline double   BEToSystem(double v)    { return SwapOrder(v); }
 
     // System (LE) to Little Endian
-    inline UByte    SystemToLE(UByte  v)    { return v; }
-    inline SByte    SystemToLE(SByte  v)    { return v; }
-    inline UInt16   SystemToLE(UInt16 v)    { return v; }
-    inline SInt16   SystemToLE(SInt16 v)    { return v; }
-    inline UInt32   SystemToLE(UInt32 v)    { return v; }
-    inline SInt32   SystemToLE(SInt32 v)    { return v; }
-    inline UInt64   SystemToLE(UInt64 v)    { return v; }
-    inline SInt64   SystemToLE(SInt64 v)    { return v; }
+    inline uint8_t  SystemToLE(uint8_t v)   { return v; }
+    inline int8_t   SystemToLE(int8_t v)    { return v; }
+    inline uint16_t SystemToLE(uint16_t v)  { return v; }
+    inline int16_t  SystemToLE(int16_t v)   { return v; }
+    inline uint32_t SystemToLE(uint32_t v)  { return v; }
+    inline int32_t  SystemToLE(int32_t v)   { return v; }
+    inline uint64_t SystemToLE(uint64_t v)  { return v; }
+    inline int64_t  SystemToLE(int64_t v)    { return v; }
     inline float    SystemToLE(float  v)    { return v; }
     inline double   SystemToLE(double v)    { return v; }   
 
     // System (LE) to Big Endian
-    inline UByte    SystemToBE(UByte  v)    { return SwapOrder(v); }
-    inline SByte    SystemToBE(SByte  v)    { return SwapOrder(v); }
-    inline UInt16   SystemToBE(UInt16 v)    { return SwapOrder(v); }
-    inline SInt16   SystemToBE(SInt16 v)    { return SwapOrder(v); }
-    inline UInt32   SystemToBE(UInt32 v)    { return SwapOrder(v); }
-    inline SInt32   SystemToBE(SInt32 v)    { return SwapOrder(v); }
-    inline UInt64   SystemToBE(UInt64 v)    { return SwapOrder(v); }
-    inline SInt64   SystemToBE(SInt64 v)    { return SwapOrder(v); }
+    inline uint8_t  SystemToBE(uint8_t v)   { return SwapOrder(v); }
+    inline int8_t   SystemToBE(int8_t v)    { return SwapOrder(v); }
+    inline uint16_t SystemToBE(uint16_t v)  { return SwapOrder(v); }
+    inline int16_t  SystemToBE(int16_t v)   { return SwapOrder(v); }
+    inline uint32_t SystemToBE(uint32_t v)  { return SwapOrder(v); }
+    inline int32_t  SystemToBE(int32_t v)   { return SwapOrder(v); }
+    inline uint64_t SystemToBE(uint64_t v)  { return SwapOrder(v); }
+    inline int64_t  SystemToBE(int64_t v)    { return SwapOrder(v); }
     inline float    SystemToBE(float  v)    { return SwapOrder(v); }
     inline double   SystemToBE(double v)    { return SwapOrder(v); }
 
 #elif (OVR_BYTE_ORDER == OVR_BIG_ENDIAN)
     // Little Endian to System (BE)
-    inline UByte    LEToSystem(UByte  v)    { return SwapOrder(v); }
-    inline SByte    LEToSystem(SByte  v)    { return SwapOrder(v); }
-    inline UInt16   LEToSystem(UInt16 v)    { return SwapOrder(v); }
-    inline SInt16   LEToSystem(SInt16 v)    { return SwapOrder(v); }
-    inline UInt32   LEToSystem(UInt32 v)    { return SwapOrder(v); }
-    inline SInt32   LEToSystem(SInt32 v)    { return SwapOrder(v); }
-    inline UInt64   LEToSystem(UInt64 v)    { return SwapOrder(v); }
-    inline SInt64   LEToSystem(SInt64 v)    { return SwapOrder(v); }
+    inline uint8_t  LEToSystem(uint8_t  v)  { return SwapOrder(v); }
+    inline int8_t   LEToSystem(int8_t v)    { return SwapOrder(v); }
+    inline uint16_t LEToSystem(uint16_t v)  { return SwapOrder(v); }
+    inline int16_t  LEToSystem(int16_t v)   { return SwapOrder(v); }
+    inline uint32_t LEToSystem(uint32_t v)  { return SwapOrder(v); }
+    inline int32_t  LEToSystem(int32_t v)   { return SwapOrder(v); }
+    inline uint64_t LEToSystem(uint64_t v)  { return SwapOrder(v); }
+    inline int64_t  LEToSystem(int64_t v)    { return SwapOrder(v); }
     inline float    LEToSystem(float  v)    { return SwapOrder(v); }
     inline double   LEToSystem(double v)    { return SwapOrder(v); }
 
     // Big Endian to System (BE)
-    inline UByte    BEToSystem(UByte  v)    { return v; }
-    inline SByte    BEToSystem(SByte  v)    { return v; }
-    inline UInt16   BEToSystem(UInt16 v)    { return v; }
-    inline SInt16   BEToSystem(SInt16 v)    { return v; }
-    inline UInt32   BEToSystem(UInt32 v)    { return v; }
-    inline SInt32   BEToSystem(SInt32 v)    { return v; }
-    inline UInt64   BEToSystem(UInt64 v)    { return v; }
-    inline SInt64   BEToSystem(SInt64 v)    { return v; }
+    inline uint8_t  BEToSystem(uint8_t v)   { return v; }
+    inline int8_t   BEToSystem(int8_t v)    { return v; }
+    inline uint16_t BEToSystem(uint16_t v)  { return v; }
+    inline int16_t  BEToSystem(int16_t v)   { return v; }
+    inline uint32_t BEToSystem(uint32_t v)  { return v; }
+    inline int32_t  BEToSystem(int32_t v)   { return v; }
+    inline uint64_t BEToSystem(uint64_t v)  { return v; }
+    inline int64_t  BEToSystem(int64_t v)    { return v; }
     inline float    BEToSystem(float  v)    { return v; }
     inline double   BEToSystem(double v)    { return v; }
 
     // System (BE) to Little Endian
-    inline UByte    SystemToLE(UByte  v)    { return SwapOrder(v); }
-    inline SByte    SystemToLE(SByte  v)    { return SwapOrder(v); }
-    inline UInt16   SystemToLE(UInt16 v)    { return SwapOrder(v); }
-    inline SInt16   SystemToLE(SInt16 v)    { return SwapOrder(v); }
-    inline UInt32   SystemToLE(UInt32 v)    { return SwapOrder(v); }
-    inline SInt32   SystemToLE(SInt32 v)    { return SwapOrder(v); }
-    inline UInt64   SystemToLE(UInt64 v)    { return SwapOrder(v); }
-    inline SInt64   SystemToLE(SInt64 v)    { return SwapOrder(v); }
+    inline uint8_t  SystemToLE(uint8_t v)   { return SwapOrder(v); }
+    inline int8_t   SystemToLE(int8_t v)    { return SwapOrder(v); }
+    inline uint16_t SystemToLE(uint16_t v)  { return SwapOrder(v); }
+    inline int16_t  SystemToLE(int16_t v)   { return SwapOrder(v); }
+    inline uint32_t SystemToLE(uint32_t v)  { return SwapOrder(v); }
+    inline int32_t  SystemToLE(int32_t v)   { return SwapOrder(v); }
+    inline uint64_t SystemToLE(uint64_t v)  { return SwapOrder(v); }
+    inline int64_t  SystemToLE(int64_t v)    { return SwapOrder(v); }
     inline float    SystemToLE(float  v)    { return SwapOrder(v); }
     inline double   SystemToLE(double v)    { return SwapOrder(v); }
 
     // System (BE) to Big Endian
-    inline UByte    SystemToBE(UByte  v)    { return v; }
-    inline SByte    SystemToBE(SByte  v)    { return v; }
-    inline UInt16   SystemToBE(UInt16 v)    { return v; }
-    inline SInt16   SystemToBE(SInt16 v)    { return v; }
-    inline UInt32   SystemToBE(UInt32 v)    { return v; }
-    inline SInt32   SystemToBE(SInt32 v)    { return v; }
-    inline UInt64   SystemToBE(UInt64 v)    { return v; }
-    inline SInt64   SystemToBE(SInt64 v)    { return v; }
+    inline uint8_t  SystemToBE(uint8_t v)   { return v; }
+    inline int8_t   SystemToBE(int8_t v)    { return v; }
+    inline uint16_t SystemToBE(uint16_t v)  { return v; }
+    inline int16_t  SystemToBE(int16_t v)   { return v; }
+    inline uint32_t SystemToBE(uint32_t v)  { return v; }
+    inline int32_t  SystemToBE(int32_t v)   { return v; }
+    inline uint64_t SystemToBE(uint64_t v)  { return v; }
+    inline int64_t  SystemToBE(int64_t v)    { return v; }
     inline float    SystemToBE(float  v)    { return v; }
     inline double   SystemToBE(double v)    { return v; }
 
@@ -983,30 +985,30 @@ namespace ByteUtil {
 
 // Used primarily for hardware interfacing such as sensor reports, firmware, etc.
 // Reported data is all little-endian.
-inline UInt16 DecodeUInt16(const UByte* buffer)
+inline uint16_t DecodeUInt16(const uint8_t* buffer)
 {
-    return ByteUtil::LEToSystem ( *(const UInt16*)buffer );
+    return ByteUtil::LEToSystem ( *(const uint16_t*)buffer );
 }
 
-inline SInt16 DecodeSInt16(const UByte* buffer)
+inline int16_t DecodeSInt16(const uint8_t* buffer)
 {
-    return ByteUtil::LEToSystem ( *(const SInt16*)buffer );
+    return ByteUtil::LEToSystem ( *(const int16_t*)buffer );
 }
 
-inline UInt32 DecodeUInt32(const UByte* buffer)
+inline uint32_t DecodeUInt32(const uint8_t* buffer)
 {    
-    return ByteUtil::LEToSystem ( *(const UInt32*)buffer );
+    return ByteUtil::LEToSystem ( *(const uint32_t*)buffer );
 }
 
-inline SInt32 DecodeSInt32(const UByte* buffer)
+inline int32_t DecodeSInt32(const uint8_t* buffer)
 {    
-    return ByteUtil::LEToSystem ( *(const SInt32*)buffer );
+    return ByteUtil::LEToSystem ( *(const int32_t*)buffer );
 }
 
-inline float DecodeFloat(const UByte* buffer)
+inline float DecodeFloat(const uint8_t* buffer)
 {
     union {
-        UInt32 U;
+        uint32_t U;
         float  F;
     };
 
@@ -1014,30 +1016,30 @@ inline float DecodeFloat(const UByte* buffer)
     return F;
 }
 
-inline void EncodeUInt16(UByte* buffer, UInt16 val)
+inline void EncodeUInt16(uint8_t* buffer, uint16_t val)
 {
-    *(UInt16*)buffer = ByteUtil::SystemToLE ( val );
+    *(uint16_t*)buffer = ByteUtil::SystemToLE ( val );
 }
 
-inline void EncodeSInt16(UByte* buffer, SInt16 val)
+inline void EncodeSInt16(uint8_t* buffer, int16_t val)
 {
-    *(SInt16*)buffer = ByteUtil::SystemToLE ( val );
+    *(int16_t*)buffer = ByteUtil::SystemToLE ( val );
 }
 
-inline void EncodeUInt32(UByte* buffer, UInt32 val)
+inline void EncodeUInt32(uint8_t* buffer, uint32_t val)
 {
-    *(UInt32*)buffer = ByteUtil::SystemToLE ( val );
+    *(uint32_t*)buffer = ByteUtil::SystemToLE ( val );
 }
 
-inline void EncodeSInt32(UByte* buffer, SInt32 val)
+inline void EncodeSInt32(uint8_t* buffer, int32_t val)
 {
-    *(SInt32*)buffer = ByteUtil::SystemToLE ( val );
+    *(int32_t*)buffer = ByteUtil::SystemToLE ( val );
 }
 
-inline void EncodeFloat(UByte* buffer, float val)
+inline void EncodeFloat(uint8_t* buffer, float val)
 {
     union {
-        UInt32 U;
+        uint32_t U;
         float  F;
     };
 
@@ -1046,12 +1048,12 @@ inline void EncodeFloat(UByte* buffer, float val)
 }
 
 // Converts an 8-bit binary-coded decimal
-inline SByte DecodeBCD(UByte byte)
+inline int8_t DecodeBCD(uint8_t byte)
 {
-    UByte digit1 = (byte >> 4) & 0x0f;
-    UByte digit2 = byte & 0x0f;
+    uint8_t digit1 = (byte >> 4) & 0x0f;
+    uint8_t digit2 = byte & 0x0f;
     int decimal = digit1 * 10 + digit2;   // maximum value = 99
-    return (SByte)decimal;
+    return (int8_t)decimal;
 }